Spreading a value based on X,Y coordinates

[Ramses]

I'm looking for an quick method to spread a sequential alterable value based on the object's position. For example - the object that is closest to the top of the screen stores 0 in an alterable value, the next one down is 1, next is 2, etc.

Right now I'm using a fastloop that has an object scan across the screen checking for overlapping objects and then numbering them. It works well on the pc, however, the project is for the iphone and this method is too sluggish for it (way too many fastloops). I'm wondering if there's another less processor intensive way to do this (using only the objects available for iOS export).

[UltimateWalrus]

Using a fastloop, enter the objects' Y positions into an array along with their fixed values. Then use fastloops to do a bubble sort on the array. Once the bubble sort is done, do a final fastloop that goes through the array and assigns the objects incremental alterable values (retrieving them from their fixed value).

This should be blindingly fast especially compared to how you're doing it now. If you wanted it even faster, and your play area isn't too huge, you could try some kind of radix sort (using the index of the array as the y position, storing only fixed values, and using the array's other index to store lists of objects that may have the same y position). This is probably how I would do it, actually, although it's a little harder to understand than a bubble sort. This solution would easily be able to handle thousands of objects, the only problem is that it would take up a lot of memory if your play area is large. It would still be fast, though.

[Ramses]

Cool. Actually, it's looking like I might not need to do any sorting as I've decided to change things around a little. That said, I messed around with a bubble sort, and although the test I put together was sloppy and basic I can see how useful it would be. Thanks for introducing me to the world of sorting algorithms! The radix sort looks interesting...

[Jacob]

While the discussion is on sorting algorithms, a binary search algorithm works great for collisions. Imagine you are moving at speed 'v'. When you hit an obstacle, move backwards by v/2. If you are still overlapping an obstacle, move backwards again by v/4, else move forwards by v/4. If you are overlapping an obstacle now, move backwards by v/8, else forward by v/8. Repeat this process with v/16, v/32, etc doubling each time. This way instead of pulling yourself out of an obstacle if you're moving at 100px/frame which could take up to 100 loops to do, you can do it in 7 because 2^7 > 100. It's a much more efficent way to handle collisions

[gkinfinity]

That's the method I used for drawing the laser in the game I've been working on for the last month actually. It worked really well.