Thread: vector out of bounds...where?

I think you mixed it up. It probably should be:

Code:

if((i*j) < spriteOneVect.size() && (i*j) < spriteTwoVect.size())

@tabstop
yep, i'm using the vector as a sort of 2D array (I don't know how to allocate memory for the 2D so I used a vector instead). Yeah, my product is probably wrong as well...VERY TIRED X[


@laserlight
Well, it detects some sort of collision now

Unfortunatly, its still off. Collision is detected but in wrong parts of bitmap...the lower half of bitmap is not being detected.

pic of game so far

little guy is link :b

How about using at at function for debugging out-of-bounds problems?

Originally Posted by dhardin

what function?

std::vector's at() member function, e.g., instead of spriteOneVect[i*j] use spriteOneVect.at(i*j). std::out_of_range will be thrown if an out of bounds condition is detected.

O.K. i'm confused by my own code. So i'm gonna think out loud to you guys.

The minX, maxX, minY, and maxY values are supposed to be the coordinates within the whole game where the collision is happening:

http://i40.tinypic.com/j9x6yu.png

the 'O' marks are my min and max values. This way it doesn't have to search the whole vector for the collision, just those coordinates.

This then returns true or false depending on what the coordinates hold (an opaque or non-opaque pixel).


Thanks for the help so far, i'm just losing myself

I had this almost working last night somehow...but it only worked when i walked to the right

Alright, well I'm no longer getting the vector out of bounds error. I found my new issue to be my lack of knowledge in directX. My initial problem was that the pink in the above image was transparent, so when I sent it to the backbuffer, my vector filled up with 1's (no non-opaque colors).

I have rewritten some of my code to make it easier to read/follow:

Code:

bool pixelCollision(int spriteOne, int spriteTwo)
{
	vector<int> spriteOneVect;
	vector<int> spriteTwoVect;
	


	/*---------------------------------------------------------------------------*/
	//                         Sprite Masking                                    //
	//                                                                           //
	/*---------------------------------------------------------------------------*/
	for(int y = 0; y < dbSpriteHeight(spriteOne); y++)
	{
		for(int x = 0; x < dbSpriteWidth(spriteOne); x++)
		{
			if(readPixel(dbGetImagePointer(spriteOne),x,y) == D3DCOLOR_XRGB(255,0,255))
			{
				spriteOneVect.push_back(0);
			}
			else
			{
				spriteOneVect.push_back(1);
			}
		}
	}
	
	for(int y = 0; y < dbSpriteHeight(spriteTwo); y++)
	{
		for(int x = 0; x < dbSpriteWidth(spriteTwo); x++)
		{
			if(readPixel(dbGetImagePointer(spriteTwo),x,y) == D3DCOLOR_XRGB(255,0,255))
			{
				spriteTwoVect.push_back(0);
			}
			else
			{
				spriteTwoVect.push_back(1);
			}
		}
	}
	
    /*---------------------------------------------------------------------------*/
	//                         Collision Overlap                                 //
	//                                                                           //
	/*---------------------------------------------------------------------------*/
	//find min and max coodinates of collision
	int minX;
	int maxX;
	int minY;
	int maxY;
	if (dbSpriteX(spriteOne) <= dbSpriteX(spriteTwo))
	{
		minX = dbSpriteX(spriteTwo);
	}
	else
	{
		minX = dbSpriteX(spriteOne);
	}
	if(dbSpriteX(spriteOne) + dbSpriteWidth(spriteOne) <= dbSpriteX(spriteTwo) + dbSpriteWidth(spriteTwo))
	{
		maxX = dbSpriteX(spriteOne) + dbSpriteWidth(spriteOne);
	}
	else
	{
		maxX = dbSpriteX(spriteTwo) + dbSpriteWidth(spriteTwo);
	}
	if(dbSpriteY(spriteOne) <= dbSpriteY(spriteTwo))
	{
		minY = dbSpriteY(spriteTwo);
	}
	else
	{
		minY = dbSpriteY(spriteOne);
	}
	if(dbSpriteY(spriteOne) + dbSpriteHeight(spriteOne) <= dbSpriteY(spriteTwo) + dbSpriteHeight(spriteTwo))
	{
		maxY = dbSpriteY(spriteOne) + dbSpriteHeight(spriteOne);
	}
	else
	{
		maxY = dbSpriteY(spriteTwo) + dbSpriteHeight(spriteTwo);
	}
	for(int y = minY; y < maxY; y++)
	{
		int spriteOneCurrentPixY = y - dbSpriteY(spriteOne);
		int spriteTwoCurrentPixY = y - dbSpriteY(spriteTwo);
		for(int x = minX; x < maxX; x++)
		{
			int spriteOneCurrentPixX = x - dbSpriteX(spriteOne);
			int spriteTwoCurrentPixX = x - dbSpriteX(spriteTwo);
			if((x*y)<spriteOneVect.size() && (x*y)<spriteTwoVect.size();
			{
				if(spriteOneVect.at(spriteOneCurrentPixX*spriteOneCurrentPixY) == spriteTwoVect.at(spriteTwoCurrentPixX*spriteTwoCurrentPixY) && 
					spriteOneVect.at(spriteOneCurrentPixX*spriteOneCurrentPixY) == 1)
				{
					return true;
				}
			}

		}
	}
	return false;
}

EDIT:
This will be a logic error. Inside the 2 loops for adding to the two vectors, i'm not so sure that the colors are being added correctly except for the character animations. THIS IS PROGRESS! So I have to get in touch with darkGDK and see if they can help me figuring out the width of each animation.