Structs and distance comparison

Hey again.

I've a struct with coordinates (x, y), and parabolic movement, so I want to check whether that missle is colliding with another missle of the same type. I did this in 2 loops, while one does the general movement stuff, and the other one is used to compare the distances.
I am using XE and my units have locust.
Is there any other (better) method to get colliding units?

Why do you need a second loop for checking distances ?

How should I check them else?
I need to check all missles whether they collide with any of the other missles.

or you could enum all units around the missile ..and check wether one of those is a missile too

Nope, they have
1st: Locust
2nd: Private protection (using xefx).

You can't access to them, only to their coordinates.

I would like to know that too!
I have two homming missiles, and I want them to collide with each other.

I could just thought of having a pointer to each other struct, but that will only make them able to collide in pairs. (So another pair of casted missiles will not collide with the previously casted ones)

Yeah, currently I am running loops, but I really would like to avoid such things.
Thats one of the bad xe things.

If the units have locust is not relevant here ... of course it is relevant that you use xefx, you have not mentioned that (you only said you use xe, which could be xebasic only aswell).
Well using xefx, a second loop is the only possibilty to do something like this, without changing xefx's code i think.

xefx would need something like a static method like getStruct4Unit takes unit u, returns xefx, which will return the corresponding xefx instance, if the unit is a xefx dummy or NULL otherwise.

Of course you could make a new struct inherit from xefx and implement something like that...and use that struct instead of xefx

Yeah, thats how I am doing it currently. Thanks anyway.

You could attach another non-locusted unit to the position of your xefx and link it with your struct, then look for that unit when checking collision.

Wehrm, and hiding it?
Is this really faster then just not creating the handle at all and running all loops?

You probably want to loop through all structs first, to make sure they have updated positions.

However, when you do the collision check afterwards, I hope you only check the distances once, since

Distance(missile1, missile2) = Distance(missile2, missile1)

In other words, begin with checking missile1 against {missile2, missile3, missile4 ...}

Now we've already checked Distance(missile1, missile2), so next:

check missile2 against {missile3, missile3 ...}
check missile3 against {missile4, ...}

Yeah, I use the current stack index as minimum index. Thanks.

I've read, that GroupEnumUnitsInRect gets locusts (just like GroupEnumUnitsOfPlayer). Haven't tried myself, but if it works, moving a rect to check for nearby other missiles wheneever you move one of them, should be much better then creating a extra unit and moving it with the xe one.

Well, that would work, however, then I enumerate on all units.

And there would be the thing that I can't get the handle ID or even the unit of xefx.