Note: I had anticipated that question and this was the unapproved, archived response.
(I don't think this response is accurate, appropriate or necessarily correct, but the choice was either post the response or send it to oblivion.)
Hypothetical situation: perhaps for an RTS simulation, where a solution using scan_entity isn't as practical or apparent:
Assuming that the player is in combat against emperor Bob (AI) and emperor Bob has a number of generals, each of these generals is in charge of an army, eLL could be used to simplify some logic in associations.
Emperor Bob could have an index to an entity linked list (a group) of generals on the board. Each general could have an index into an entity linked list of its army. If Emperor Bob needs to know the status of all of his armies, he can iterate through the list of generals, each general can iterate through their armies, if necessary, and return the results back to Emperor Bob. If while iterating through the list, Emperor Bob requests the status of an army A, the position of the army, etc., learns that army A is hopelessly outnumbered, and has previously noted that another general controlling army B has an army doing nothing nearby, Emperor Bob may instruct general of army B to move army B to the position of army A. To do this, the Emperor instructs the general, and the general instructs the army (iterating through the army if necessary).
If a general is about to die, perhaps Emperor Bob can access the army directly, by grabbing the generals index into the entity linked list of the general's army. Emperor Bob can then promote a new general, by selecting a candidate, assigning the army index grabbed from the dying general to the candidate and placing the candidate into Emperor Bob's list of generals.
You might use eLL to have a leader of a squad, coordinate the movements of a squad.
If you only have a few opposing squads in combat against each other, given that some functionality is sacrificed or replaced,
eLL may be faster than scan_entity for target assignment.
Hypothetical situation: If you have every StormTrooper in the level looking for targets player, HanSolo and R2D2, with scan_entity (not every frame),perhaps using eLL instead, and adding targets player, HanSolo and R2D2 to an eLL 0, having the StormTroopers iterate through eLL 0, check the distances of each entity in eLL 0, and if entity is in range, assign the entity as a target (perhaps assign the weakest, nearest entity as the target), perform a look trace to see if the my StormTrooper can see the target entity, then such may be faster than doing something similar with scan_entity.
Essentially, eLL offers dynamic groups of entities (maybe for team against team play).
Exactly how do you currently count specific entities in a specific area using scan_entity?
If I want to know the count of StormTroopers (perhaps after some have died(been removed) and others have been added) when the index into the linked list of StormTroopers is 1,
Code:
// assuming eLLPush(1, my) at beginning of StormTrooper action
var stormTrooperCount = eLLGetLength(1);
If I want to know how many StormTroopers are near a position + the weakest StormTrooper without using scan_entity:
Code:
entity* ent0_;
entity* ent1_;
//...
stormTrooperCount = 0;
if (!eLLIsEmpty(1)) {
var position[3];
var healthMin = 100;
eLLNextReset(1);
ent0_ = eLLNext(1);
ent1_ = ent0_;
while (ent0_ != null) {
if (vec_dist(ent0_.x, position) < 100) { // he's near position
stormTrooperCount += 1; // add one to how many StormTroopers are near position
if (ent0_.health < healthMin) {
ent1_ = ent0_;
healthMin = ent0_.health;
}
}
ent0_ = eLLNext(1);
}
}
// if ent1_ != null, HanSolo can target the weakest StormTrooper near position
Again, you could use eLL to move entities as a group, get the average position of the group, keep entities in formation, etc.
Note that eLL is meant to represent a dynamic list of entities, and not an array of entities, but in some cases, it can be used in place of a static array of handles.
