How to determine an irregular area of a CCSprite?

Question

In my simple game I use boundingBox for pick coins and other stuff, but I need use irregular area detection of Sprite(with out Alpha)... There is alternative to boundingBox? Here is code:

-(void)ccTouchEnded:(UITouch *)touch withEvent:(UIEvent *)event {
CGPoint location = [touch locationInView:[touch view]];
CGPoint point = [[CCDirector sharedDirector] convertToGL:location];
curentPosition = point;
arrToDel = [[NSMutableArray alloc] initWithCapacity:0];

CCSprite *coin = nil;

for (Coins *coins in self.bugs) {
    if (CGRectContainsPoint([coins boundingBox], curentPosition)) {
        coin = coins; // found sprite
    }
}

if (coin != nil) {
    NSMutableArray *checkList = [NSMutableArray arrayWithCapacity:0];

    for (Coins *coins in self.bugs) {
        if (CGRectIntersectsRect([coin boundingBoxInPixels], [coins boundingBox]) && coins != coin) {
            [checkList addObject:coins];
        }
    }

    int max = coin.zOrder;

    for (Coins *b in checkList) {
        if (b.zOrder > max)
            max = b.zOrder;
    }

    if (max == coin.zOrder) {

        [self removeChild:coin cleanup:YES];

        [arrToDel addObject:coin];

        for (Coins *coins in  arrToDel) {

            [self.bugs removeObject:coin];

        }
    }
}

}

Answer 1

For this you may use CGPath. You can find answer on your question here

Answer 2

If your sprites can be decomposed into a series of bounding boxes or other easy-to-detect primitive shapes, you could use that collection of bounding boxes instead. That probably won't scale, however, -- a more common approach is to use collision masks. A mask is essentially a B&W version of the sprite where white means "not part of the sprite" and black means "part of the sprite."

If your source sprites have alpha or color key data, you can either use directly as the mask or use it produce the mask images programmatically. Otherwise you may need to author the mask images in a paint program.

Anyhow, once you have the mask you first do a simple bounding-box check to trivially reject collisions that aren't even close. Then you test against the mask image -- in this case it looks like you'd transform currentPosition into the local space of the mask image (subtract the current position from the origin of the bounding box) and then see if the pixel in the mask at the transformed index was black or white, and that will let you know if the user touched part of the sprite or not.

Note that you may also find that you'll need to enlarge the hit test area from a single pixel in order to make this feel good, especially on a real phone when you're using real fingers as the input instead of a mouse on the simulator.

Answer 3

If the sprite doesn't change, you could give it a convex bounding polygon. Computing collisions is more complicated than with rectangles, but not much more.

Even if it does change, computing an appropriate polygon at runtime is not terribly hard.