//Enemy projectile collide

	collideCounter = 0;
	
	for (iter2 = projArray.begin(); iter2 != projArray.end(); iter2++){
		collideCounter2 = 0;

		for (iter3 = projArray.begin(); iter3 != projArray.end(); iter3++){
			if (projArray[collideCounter].rect.getGlobalBounds().intersects(enemy.enemyArray[collideCounter2].enemySprite.getGlobalBounds()))
			{
				std::cout << "COLLIDE" << std::endl;
			}

			collideCounter2++;
		}
		collideCounter++;
	}

Seems to be the 2nd for loop giving me the subscript out of range. I have no idea where to start looking, it could be the amount of bullets that are being spawned because if I click my mouse fast, it will only spawn a few bullets instead of like 8-10 so maybe its conflicting with the collision but I'm not sure, only this part of the code is giving me the error.

On your specific error, probably you are expecting to iterate over enemy.enemyArray for the inner loop rather than projArray.

If that was a typo in your post but different in your actual code, stop that in the debugger when the error occurs and look at the values of collideCounter and collideCounter2. You should find that one of them exceeds the length of the array they are being used on, either projArray or enemyArray.


As for the general condition, I sure hope you have a small number of items in those arrays. That kind of all-to-all comparison results in dangerously fast computational growth. Most systems build spatial trees and only compare the immediate neighbors.

wow thanks a lot! can't believe I was overlooking that this whole time

We are sooo good at reading what we think rather than what it says

for (const auto& item : myArray)
{
  // do some calculation with item - which is basically "myArray[i]"
}

for (const auto& item : myArray)
{
  // do some calculation with item - which is basically "myArray[i]"
}

Why are you using iterators in your for loops, in addition to counters? Just dereference the iterator...

	//Enemy projectile collide
	
	for (iter2 = projArray.begin(); iter2 != projArray.end(); ++iter2){

		for (iter3 = enemy.enemyArray.begin(); iter3 != enemy.enemyArray.end(); ++iter3){
			if (*iter2.rect.getGlobalBounds().intersects(*iter3.enemySprite.getGlobalBounds()))
			{
				std::cout << "COLLIDE" << std::endl;
			}

		}
	}

I don't have experience with this:

for (const auto& item : myArray)
{
  // do some calculation with item - which is basically "myArray[i]"
}

const auto endIter = end(myArray);
for (auto iter = begin(myArray); iter != endIter; ++iter)
{
  const auto& item = *endIter;
  // do stuff here
}

int myArray[20];
// fill myArray
for (const auto& item : myArray)
{
  // do stuff with the items
}

int* myArray = new int[size];
// fill myArray
for (const auto& item : myArray) // compile error!
{
  // do stuff with the items
}
delete [] myArray;

Thanks. Since I don't have experience with it, I couldn't use it as an example. It appears to be the better way though.

Though in Java i expect the principle to be applicable in C++

Nope. There does not exist anything like hasNext or conversion between iterators and indexes (previousIndex) in C++