Nice exercise in a time of MMO wannabe!

I will try to turn to black the color of some of the green pixels nearby the point of impact.

In this case, you might want to do a per-pixel intersection test, since your blocks are going to not be rectangle after they have been hit a few times.

What that means is, do a typical rectangle intersection test between the bullet and the block. once you've confirmed it's within the rectangle, then do a pixel-by-pixel comparison of where the bullet will be next frame, and the color of the block at that location. If it's black, then it's not hit. if it's green, then you can just put a small black circle (or some other algorithm) near the spot of impact as the crater the bullet's explosion creates.

Just a thought. Good luck and have fun.

where the bullet will be next frame, and the color of the block at that location.

How to do that in pseudocode?

It depends on how you are storing your "blocks." Are they bitmaps rendered to a surface that can be manipulated, or are you just drawing rectangles? Assuming it's a bitmap that was originally rendered to a surface, then it'd be something like this:

// Create a rectangle where the bullet is moving to this frame
TRect NewBulletRect = Bullet.Rect + Bullet.Velocity;
 
// check if the bullet and block will be intersecting
if (RectIntersect(NewBulletRect , Block.Rect)) {
  // find the offset within the block's rect the bullet is to check the color within the block's surface
  Vector2D BulletLocationInBlock = Bullet.Rect - Block.Rect;
 
  // now check the color of the Block at the leading location of the Bullet
  // we need to know the pixel depth, which is probably 32-bits, and possibly the pitch, which should be bitmap width * pixel depth
  TColor BlockLocationColor = Block.Surface.Memory + (Block.Surface.Pitch * BulletLocationInBlock.Y) + (BulletLocationInBlock.X * Block.Surface.BitsPerPixel);
 
  // Check if it's black (which means the RGB value is 0, but you have to know the layout of the pixels; is Alpha the 1st byte or the last?  I'll assume 1st)
  if ((BlockLocationColor & 0xFFFFFF) != 0) {
    // it's not black, so it hit the block
    // Draw a circle on the Block's Surface to indicate crater, and so the next bullet will continue this this location
    ...
  }

It's obvious pseudo-code, but it should make sense. If you don't know how the data is stored in the surfaces, you may need to experiment some, or do a little research on how graphics bitmap data is stored on surfaces.

Good luck.

Thanks but I didn't get this:

// find the offset within the block's rect the bullet is to check the color within the block's surface
Vector2D BulletLocationInBlock = Bullet.Rect - Block.Rect;

is that ? in equations it should be Abs(X1-X2), Abs(Y1-Y2) ?

I tried to visualize it, but still didn't clear it up

Just imagine the bullet falling into the block. Now, you need to determine, where in reference to the block (where 0, 0 is the Block's upper left) the end of the bullet is. So, it'd be The Bullet's BottomY minus the Block's TopY. that would give you how deep the bullet penetrated. Same with X, take the Bullet's Middle-X minus the Block's Left-X, and you'll have the bullet's offset within the block.

hope that makes sense.

I have tried your algorithm, but pixels of the original image never get overwritten, I have a logical problem there but can't get it

so first

1. is colliding

2. get the intersected rect

3. modify pixels <-- not working probably

cRect Intersection(const cRect& boundsA, const cRect& boundsB)
{
	int x1 = Maximum(boundsA.x, boundsB.x);
	int y1 = Maximum(boundsA.y, boundsB.y);
	int x2 = Minimum(boundsA.x + boundsA.w, boundsB.x + boundsB.w);
	int y2 = Minimum(boundsA.y + boundsA.h, boundsB.y + boundsB.h);

	int width = x2 - x1;
	int height = y2 - y1;

	if (width > 0 && height > 0)
	{
		cRect intersect;
		intersect.x = x1;
		intersect.y = y1;
		intersect.w = width;
		intersect.h = height;
		return intersect;
	}
	else
	{
		cRect intersect;
		intersect.x = 0;
		intersect.y = 0;
		intersect.w = 0;
		intersect.h = 0;
		return intersect;
	}
}


// check collision function() 
bool CheckCollisionNewBarriers(Ship *ship, vector<Barrier*> *barriers, CIwTexture *tex, uint8*pixels, uint32 pitch)
{
for (vector<Barrier*>::iterator itBarrier = barriers->begin(); itBarrier != barriers->end();)
	{
		for (list<Bullet*>::iterator it = ship->Bullets->begin(); it != ship->Bullets->end();)
		{
			if (IntersectsWith((*it)->BoundingRect, (*itBarrier)->BoundingRect))
			{

				cRect bounding = Intersection((*it)->BoundingRect, (*itBarrier)->BoundingRect);
				Iw2DDrawRect(CIwFVec2(bounding.x, bounding.y),CIwFVec2(20,20));
			
				int bpp = 4;
				uint8 pixelOffset = bounding.x*bpp + bounding.y*pitch;
				pixels[pixelOffset] = 0xff000000;
 				 
				tex->ChangeTexels(pixels);
				tex->Upload();
                              } 
                            }
 

Crap, it lost my changes. Well, let me re-write...

Iw2DDrawRect(CIwFVec2(bounding.x, bounding.y),CIwFVec2(20,20));

int bpp = 4;
uint8 pixelOffset = bounding.x*bpp + bounding.y*pitch;
pixels[pixelOffset] = 0xff000000;
  
tex->ChangeTexels(pixels);
tex->Upload();