What should be the code design for interactions management in a game with lots of object?

Question

I'm writing a 2d game for Android in Java using LibGDX. The game consists many interactions between different types of objects. Most of them happen between enemies and bullets. At the beginning, I needed to check every moment if any enemy collide any bullet (if their masks overlaps each other). The code for checking overlap is clear to me. My question is how should I make the interactions be checked between everyone every moment?

What I did is creating a class called InteractionsManager which takes the array of all enemies and the array of bullets and checking in every step collision between each other (if collision happens, it calls the object's onCollision(Object object) method).

My problem got bigger when I needed to check other interactions types (like if enemy is in a specific distance from other type of object and other stuff like that).

I thought about passing to each object the InteractionsManager object and it should tell it whatever interaction it needs.

Answer 1

I'm not sure if its a good solution but i use to add x, y and z (gonna call this XYZ from now) and store it in a linked list with an object identifier and the average side size (we gonna asume that, in this example the object is a cube of 20x20x20 so 20*3/3 = 20).

//PSEUDOCODE
MYOBJECT ob(/*id*/ 1, /*size*/ 20, /*x*/ 30, /*y*/ 12, /*z*/ 4);

forward_list<float[3]> control;

control.push_back([1 /*ID*/ , 46 /*sum of all axis*/, 20 /*size*/]);

And, in every iteration, loop through the control list and check for collisions only between the object's who has XYZ equal or greater than his own XYZ (+/-) his own size*2.

//PSEUDOCODE
obj A
check B if
    (A.XYZ - (A.S * 3) >= B.XYZ + (B.S * 3)) &&
    (A.XYZ + (A.S * 3) <= B.XYZ - (B.S * 3))
if true add [A,B] to check_if_collide

I use this approach cause it doesn't check for collisions in objects too far and does not asume two objects are colliding when they aren't cause, after this "filter" you would have to check the collision as you would normally, but you gonna have a much short array of objects that are probably hitting each others.

hope it helps

Answer 2

Disclaimer: This answer is 100% subjective, it is related to code design personal preferences and might not be the best answer.

I would delete InteractionsManager class.

The idea of having 2 lists (arrays) and checking for collision in a loop is nice, but you can do that on your Screen class. (just create a checkCollisions() method and call it on render()). The code will remain the same, no performance increase, but usually having too many classes might make the code hard to understand.

If you need more interaction types, you can follow the same idea: create a new function in your Screen class and call it on render().

I can´t really help you with performance without seeing the code.