Good day everyone, first poster long time follower here, i have a sorta conceptual question. I have already searched the forums and found nothing so here it is:
I have a 2D space identified by the typical X and Y axis on C++ float.
There are multiple "entities" modeled as Entity class instances(the class have all the methods needed to manage the entity).
The entity also have an "area" defined by some function(for now just circle and square) applied on the origin point of that entity, and they move.
Now, when entity A and B's area overlaps i need to execute the A.somemethod(B) and B.somemethod(A), the problem is: I can't think of any method to do that, at least somewhat efficiently, but i know it can be done, if someone can spare some advice, i'll be grateful

It seems to be a basic collision-detection problematic. It's a really wide subject and it's really depends on what are your requirements, what do you want to achieve and what tools are you using?
Basically , the first part of a collision-detection process is of couse detect if a pair of entities are actually overlapping. But here again it really depends of what you want to achieve (give us more informations about that), there are dozen of ways/algorithms to do it. Generally, this part of the process is divided in two parts:

• The Broad-Phase. Here is a great tutorial that expose a way to go: http://www.metanetso.../tutorialB.html. Basically in this phase, your goal is to quickly find all the entities that would eventually collide with the entity you are currently proceeding. There is no overlap test here.
  
• The Narrow-Phase: Once you know all the entities that would potentially overlap your current entity, you have to do the actual collision test against the current entity and all the potentially overlapping entities. For this part, refer to the Bacterius post and to this tutorial http://www.metanetso.../tutorialA.html.
  

The algorithm could be something like:


function collisionDetection(Entity currentEntity) {
collidableEntities = doBroadPhase(currentEntity) //collidableEntities here could be a list of potentially overlapping entities
foreach ( ce : collidableEntities) {
if (doNarrowPhase(currentEntity, ce)) {
//the current entity is overlapping this entity
//do something
}
}

//and once per frame in your game loop
foreach (e : entities) {//entities is here all your entities
collisionDetection(e)
}
}


Thank you Nathan, i too think it's something linked to collision detection... The situation i am modeling is: There's an EMP grenade with a certain effect range. And there are some silicon wafers with a certain shape. Now when the grenade explode it will trigger some effects on any wafer that have any amount of surface affected.
Doing the standard CollDect that you suggested seem to me a little too inefficient, i am wondering if exist some way to say to a crowd of objects "hey anyone that have a toe in this area should do this" without checking for each one of them

@Elu to know if entities are overlapping a given area (e.g in your case it would be the range of your EMP grenade), you will need to proceed all the entities and see if they are overlapping the area. I put "all" in italic since you will never check ALL the entities (in an efficient collision-detection system, of course you could check each entity against all entity i.e do a brute force but it's not what you want) and that's the goal of the Broad-Phase, reduce the number of entity too proceed by grabbing only the entities that wil have a chance to actually overlap with your area. A Broad-Phase can be implemented using an uniform grid, a quad tree, a BSP tree, it all depends of what you want to achieve.

Doing the standard CollDect that you suggested seem to me a little too inefficient, i am wondering if exist some way to say to a crowd of objects "hey anyone that have a toe in this area should do this" without checking for each one of them[/quote]

• i am wondering if exist some way to say to a crowd of objects: it's the Broad-Phase of your collision-detection process
  
• without checking for each one of them: programmation is not magical