如何使用Box2D和Cocos2D制作一款像Fruit Ninja一样的游戏-第2部分

// Add inside the @interface
BOOL _sliceEntered;
BOOL _sliceExited;
b2Vec2 _entryPoint;
b2Vec2 _exitPoint;
double _sliceEntryTime;

// Add after the @interface
@property(nonatomic,readwrite)BOOL sliceEntered;
@property(nonatomic,readwrite)BOOL sliceExited;
@property(nonatomic,readwrite)b2Vec2 entryPoint;
@property(nonatomic,readwrite)b2Vec2 exitPoint;
@property(nonatomic,readwrite)double sliceEntryTime;

// Add inside the @implementation
@synthesize entryPoint = _entryPoint;
@synthesize exitPoint = _exitPoint;
@synthesize sliceEntered = _sliceEntered;
@synthesize sliceExited = _sliceExited;
@synthesize sliceEntryTime = _sliceEntryTime;

// Add inside the initWithTexture method, inside the if statement
_sliceExited = NO;
_sliceEntered = NO;
_entryPoint.SetZero();
_exitPoint.SetZero();
_sliceExited = 0;

CGPoint _startPoint;
CGPoint _endPoint;

// Add inside the draw method after kmGLPushMatrix()
ccDrawLine(_startPoint, _endPoint);

// Add this method
-(void)ccTouchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
for (UITouch *touch in touches){
CGPoint location = [touch locationInView:[touch view]];
location = [[CCDirector sharedDirector] convertToGL:location];
_startPoint = location;
_endPoint = location;
}
}

// Add this method
- (void)ccTouchesMoved:(NSSet *)touches withEvent:(UIEvent *)event
{
for (UITouch *touch in touches){
CGPoint location = [touch locationInView:[touch view]];
location = [[CCDirector sharedDirector] convertToGL:location];
_endPoint = location;
}
}

#ifndef CutCutCut_RaycastCallback_h
#define CutCutCut_RaycastCallback_h

#import "Box2D.h"
#import "PolygonSprite.h"

class RaycastCallback : public b2RayCastCallback
{
public:
RaycastCallback(){
}

float32 ReportFixture(b2Fixture *fixture,const b2Vec2 &point,const b2Vec2 &normal,float32 fraction)
{
PolygonSprite *ps = (PolygonSprite*)fixture->GetBody()->GetUserData();
if (!ps.sliceEntered)
{
ps.sliceEntered = YES;

//you need to get the point coordinates within the shape
ps.entryPoint  = ps.body->GetLocalPoint(point);

ps.sliceEntryTime = CACurrentMediaTime() + 1;
CCLOG(@"Slice Entered at world coordinates:(%f,%f), polygon coordinates:(%f,%f)", point.x*PTM_RATIO, point.y*PTM_RATIO, ps.entryPoint.x*PTM_RATIO, ps.entryPoint.y*PTM_RATIO);
}
else if (!ps.sliceExited)
{
ps.exitPoint = ps.body->GetLocalPoint(point);
ps.sliceExited = YES;

CCLOG(@"Slice Exited at world coordinates:(%f,%f), polygon coordinates:(%f,%f)", point.x*PTM_RATIO, point.y*PTM_RATIO, ps.exitPoint.x*PTM_RATIO, ps.exitPoint.y*PTM_RATIO);
}
return 1;
}
};

#endif

// Add to top of file
#import "RaycastCallback.h"

// Add inside the @interface
RaycastCallback *_raycastCallback;

// Add inside the init method, right after [self initSprites]
_raycastCallback = new RaycastCallback();

// Add at the end of the ccTouchesEnded method
world->RayCast(_raycastCallback,
b2Vec2(_startPoint.x / PTM_RATIO, _startPoint.y / PTM_RATIO),
b2Vec2(_endPoint.x / PTM_RATIO, _endPoint.y / PTM_RATIO));

world->RayCast(_raycastCallback,
b2Vec2(_endPoint.x / PTM_RATIO, _endPoint.y / PTM_RATIO),
b2Vec2(_startPoint.x / PTM_RATIO, _startPoint.y / PTM_RATIO));

// Add to top of file
#define calculate_determinant_2x2(x1,y1,x2,y2) x1*y2-y1*x2
#define calculate_determinant_2x3(x1,y1,x2,y2,x3,y3) x1*y2+x2*y3+x3*y1-y1*x2-y2*x3-y3*x1

// Add after the properties
-(b2Vec2*)arrangeVertices:(b2Vec2*)vertices count:(int)count;
-(void)splitPolygonSprite:(PolygonSprite*)sprite;
-(BOOL)areVerticesAcceptable:(b2Vec2*)vertices count:(int)count;
-(b2Body*)createBodyWithPosition:(b2Vec2)position rotation:(float)rotation vertices:(b2Vec2*)vertices vertexCount:(int32)count density:(float)density friction:(float)friction restitution:(float)restitution;

-(void)splitPolygonSprite:(PolygonSprite*)sprite
{
//declare & initialize variables to be used for later
PolygonSprite *newSprite1, *newSprite2;

//our original shape's attributes
b2Fixture *originalFixture = sprite.body->GetFixtureList();
b2PolygonShape *originalPolygon = (b2PolygonShape*)originalFixture->GetShape();
int vertexCount = originalPolygon->GetVertexCount();

//our determinant(to be described later) and iterator
float determinant;
int i;

//you store the vertices of our two new sprites here
b2Vec2 *sprite1Vertices = (b2Vec2*)calloc(24, sizeof(b2Vec2));
b2Vec2 *sprite2Vertices = (b2Vec2*)calloc(24, sizeof(b2Vec2));
b2Vec2 *sprite1VerticesSorted, *sprite2VerticesSorted;

//you store how many vertices there are for each of the two new sprites here
int sprite1VertexCount = 0;
int sprite2VertexCount = 0;

//step 1:
//the entry and exit point of our cut are considered vertices of our two new shapes, so you add these before anything else
sprite1Vertices[sprite1VertexCount++] = sprite.entryPoint;
sprite1Vertices[sprite1VertexCount++] = sprite.exitPoint;
sprite2Vertices[sprite2VertexCount++] = sprite.entryPoint;
sprite2Vertices[sprite2VertexCount++] = sprite.exitPoint;

//step 2:
//iterate through all the vertices and add them to each sprite's shape
for (i=0; i<vertexCount; i++)
{
//get our vertex from the polygon
b2Vec2 point = originalPolygon->GetVertex(i);

//you check if our point is not the same as our entry or exit point first
b2Vec2 diffFromEntryPoint = point - sprite.entryPoint;
b2Vec2 diffFromExitPoint = point - sprite.exitPoint;

if ((diffFromEntryPoint.x == 0 && diffFromEntryPoint.y == 0) || (diffFromExitPoint.x == 0 && diffFromExitPoint.y == 0))
{
}
else
{
determinant = calculate_determinant_2x3(sprite.entryPoint.x, sprite.entryPoint.y, sprite.exitPoint.x, sprite.exitPoint.y, point.x, point.y);

if (determinant > 0)
{
//if the determinant is positive, then the three points are in clockwise order
sprite1Vertices[sprite1VertexCount++] = point;
}
else
{
//if the determinant is 0, the points are on the same line. if the determinant is negative, then they are in counter-clockwise order
sprite2Vertices[sprite2VertexCount++] = point;

}//endif
}//endif
}//endfor

//step 3:
//Box2D needs vertices to be arranged in counter-clockwise order so you reorder our points using a custom function
sprite1VerticesSorted = [self arrangeVertices:sprite1Vertices count:sprite1VertexCount];
sprite2VerticesSorted = [self arrangeVertices:sprite2Vertices count:sprite2VertexCount];

//step 4:
//Box2D has some restrictions with defining shapes, so you have to consider these. You only cut the shape if both shapes pass certain requirements from our function
BOOL sprite1VerticesAcceptable = [self areVerticesAcceptable:sprite1VerticesSorted count:sprite1VertexCount];
BOOL sprite2VerticesAcceptable = [self areVerticesAcceptable:sprite2VerticesSorted count:sprite2VertexCount];

//step 5:
//you destroy the old shape and create the new shapes and sprites
if (sprite1VerticesAcceptable && sprite2VerticesAcceptable)
{
//create the first sprite's body
b2Body *body1 = [self createBodyWithPosition:sprite.body->GetPosition() rotation:sprite.body->GetAngle() vertices:sprite1VerticesSorted vertexCount:sprite1VertexCount density:originalFixture->GetDensity() friction:originalFixture->GetFriction() restitution:originalFixture->GetRestitution()];

//create the first sprite

newSprite1 = [PolygonSprite spriteWithTexture:sprite.texture body:body1 original:NO];
[self addChild:newSprite1 z:1];

//create the second sprite's body
b2Body *body2 = [self createBodyWithPosition:sprite.body->GetPosition() rotation:sprite.body->GetAngle() vertices:sprite2VerticesSorted vertexCount:sprite2VertexCount density:originalFixture->GetDensity() friction:originalFixture->GetFriction() restitution:originalFixture->GetRestitution()];

//create the second sprite
newSprite2 = [PolygonSprite spriteWithTexture:sprite.texture body:body2 original:NO];
[self addChild:newSprite2 z:1];

//you don't need the old shape & sprite anymore so you either destroy it or squirrel it away
if (sprite.original)
{
[sprite deactivateCollisions];
sprite.position = ccp(-256,-256);   //cast them faraway
sprite.sliceEntered = NO;
sprite.sliceExited = NO;
sprite.entryPoint.SetZero();
sprite.exitPoint.SetZero();
}
else
{
world->DestroyBody(sprite.body);
[self removeChild:sprite cleanup:YES];
}
}
else
{
sprite.sliceEntered = NO;
sprite.sliceExited = NO;
}

//free up our allocated vectors
free(sprite1VerticesSorted);
free(sprite2VerticesSorted);
free(sprite1Vertices);
free(sprite2Vertices);
}

// Add before the @implementation
int comparator(const void *a, const void *b) {
const b2Vec2 *va = (const b2Vec2 *)a;
const b2Vec2 *vb = (const b2Vec2 *)b;

if (va->x > vb->x) {
return 1;
} else if (va->x < vb->x) {
return -1;
}
return 0;
}

// Add these methods
-(b2Body*)createBodyWithPosition:(b2Vec2)position rotation:(float)rotation vertices:(b2Vec2*)vertices vertexCount:(int32)count density:(float)density friction:(float)friction restitution:(float)restitution
{
b2BodyDef bodyDef;
bodyDef.type = b2_dynamicBody;
bodyDef.position = position;
bodyDef.angle = rotation;
b2Body *body = world->CreateBody(&bodyDef);

b2FixtureDef fixtureDef;
fixtureDef.density = density;
fixtureDef.friction = friction;
fixtureDef.restitution = restitution;

b2PolygonShape shape;
shape.Set(vertices, count);
fixtureDef.shape = &shape;
body->CreateFixture(&fixtureDef);

return body;
}

-(b2Vec2*)arrangeVertices:(b2Vec2*)vertices count:(int)count
{
float determinant;
int iCounterClockWise = 1;
int iClockWise = count - 1;
int i;

b2Vec2 referencePointA,referencePointB;
b2Vec2 *sortedVertices = (b2Vec2*)calloc(count, sizeof(b2Vec2));

//sort all vertices in ascending order according to their x-coordinate so you can get two points of a line
qsort(vertices, count, sizeof(b2Vec2), comparator);

sortedVertices[0] = vertices[0];
referencePointA = vertices[0];          //leftmost point
referencePointB = vertices[count-1];    //rightmost point

//you arrange the points by filling our vertices in both clockwise and counter-clockwise directions using the determinant function
for (i=1;i<count-1;i++)
{
determinant = calculate_determinant_2x3(referencePointA.x, referencePointA.y, referencePointB.x, referencePointB.y, vertices[i].x, vertices[i].y);
if (determinant<0)
{
sortedVertices[iCounterClockWise++] = vertices[i];
}
else
{
sortedVertices[iClockWise--] = vertices[i];
}//endif
}//endif

sortedVertices[iCounterClockWise] = vertices[count-1];
return sortedVertices;
}

-(BOOL)areVerticesAcceptable:(b2Vec2*)vertices count:(int)count
{
return YES;
}

// Add this method
-(void)checkAndSliceObjects
{
double curTime = CACurrentMediaTime();
for (b2Body* b = world->GetBodyList(); b; b = b->GetNext())
{
if (b->GetUserData() != NULL) {
PolygonSprite *sprite = (PolygonSprite*)b->GetUserData();

if (sprite.sliceEntered && curTime > sprite.sliceEntryTime)
{
sprite.sliceEntered = NO;
}
else if (sprite.sliceEntered && sprite.sliceExited)
{
[self splitPolygonSprite:sprite];
}
}
}
}

// Add this in the update method
[self checkAndSliceObjects];

// Add this method
-(void)clearSlices
{
for (b2Body* b = world->GetBodyList(); b; b = b->GetNext())
{
if (b->GetUserData() != NULL) {
PolygonSprite *sprite = (PolygonSprite*)b->GetUserData();
sprite.sliceEntered = NO;
sprite.sliceExited = NO;
}
}
}

// Add this at the end of ccTouchesMoved
if (ccpLengthSQ(ccpSub(_startPoint, _endPoint)) > 25)
{
world->RayCast(_raycastCallback,
b2Vec2(_startPoint.x / PTM_RATIO, _startPoint.y / PTM_RATIO),
b2Vec2(_endPoint.x / PTM_RATIO, _endPoint.y / PTM_RATIO));

world->RayCast(_raycastCallback,
b2Vec2(_endPoint.x / PTM_RATIO, _endPoint.y / PTM_RATIO),
b2Vec2(_startPoint.x / PTM_RATIO, _startPoint.y / PTM_RATIO));
_startPoint = _endPoint;
}

// Remove these from ccTouchesEnded
world->RayCast(_raycastCallback,
b2Vec2(_startPoint.x / PTM_RATIO, _startPoint.y / PTM_RATIO),
b2Vec2(_endPoint.x / PTM_RATIO, _endPoint.y / PTM_RATIO));

world->RayCast(_raycastCallback,
b2Vec2(_endPoint.x / PTM_RATIO, _endPoint.y / PTM_RATIO),
b2Vec2(_startPoint.x / PTM_RATIO, _startPoint.y / PTM_RATIO));

// Add this inside ccTouchesEnded
[self clearSlices];

// Remove the CCLOG commands

// Add to top of file
#define collinear(x1,y1,x2,y2,x3,y3) fabsf((y1-y2) * (x1-x3) - (y1-y3) * (x1-x2))

// Remove this line from the else if statement
ps.sliceExited = YES;

// Add this inside the else if statement, right after setting the exitPoint
b2Vec2 entrySide = ps.entryPoint - ps.centroid;
b2Vec2 exitSide = ps.exitPoint - ps.centroid;

if (entrySide.x * exitSide.x < 0 || entrySide.y * exitSide.y < 0)
{
ps.sliceExited = YES;
}
else {
//if the cut didn't cross the centroid, you check if the entry and exit point lie on the same line
b2Fixture *fixture = ps.body->GetFixtureList();
b2PolygonShape *polygon = (b2PolygonShape*)fixture->GetShape();
int count = polygon->GetVertexCount();

BOOL onSameLine = NO;
for (int i = 0 ; i < count; i++)
{
b2Vec2 pointA = polygon->GetVertex(i);
b2Vec2 pointB;

if (i == count - 1)
{
pointB = polygon->GetVertex(0);
}
else {
pointB = polygon->GetVertex(i+1);
}//endif

float collinear = collinear(pointA.x,pointA.y, ps.entryPoint.x, ps.entryPoint.y, pointB.x,pointB.y);

if (collinear <= 0.00001)
{
float collinear2 = collinear(pointA.x,pointA.y,ps.exitPoint.x,ps.exitPoint.y,pointB.x,pointB.y);
if (collinear2 <= 0.00001)
{
onSameLine = YES;
}
break;
}//endif
}//endfor

if (onSameLine)
{
ps.entryPoint = ps.exitPoint;
ps.sliceEntryTime = CACurrentMediaTime() + 1;
ps.sliceExited = NO;
}
else {
ps.sliceExited = YES;
}//endif
}

-(BOOL)areVerticesAcceptable:(b2Vec2*)vertices count:(int)count
{
//check 1: polygons need to at least have 3 vertices
if (count < 3)
{
return NO;
}

//check 2: the number of vertices cannot exceed b2_maxPolygonVertices
if (count > b2_maxPolygonVertices)
{
return NO;
}

//check 3: Box2D needs the distance from each vertex to be greater than b2_epsilon
int32 i;
for (i=0; i<count; ++i)
{
int32 i1 = i;
int32 i2 = i + 1 < count ? i + 1 : 0;
b2Vec2 edge = vertices[i2] - vertices[i1];
if (edge.LengthSquared() <= b2_epsilon * b2_epsilon)
{
return NO;
}
}

//check 4: Box2D needs the area of a polygon to be greater than b2_epsilon
float32 area = 0.0f;

b2Vec2 pRef(0.0f,0.0f);

for (i=0; i<count; ++i)
{
b2Vec2 p1 = pRef;
b2Vec2 p2 = vertices[i];
b2Vec2 p3 = i + 1 < count ? vertices[i+1] : vertices[0];

b2Vec2 e1 = p2 - p1;
b2Vec2 e2 = p3 - p1;

float32 D = b2Cross(e1, e2);

float32 triangleArea = 0.5f * D;
area += triangleArea;
}

if (area <= 0.0001)
{
return NO;
}

//check 5: Box2D requires that the shape be Convex.
float determinant;
float referenceDeterminant;
b2Vec2 v1 = vertices[0] - vertices[count-1];
b2Vec2 v2 = vertices[1] - vertices[0];
referenceDeterminant = calculate_determinant_2x2(v1.x, v1.y, v2.x, v2.y);

for (i=1; i<count-1; i++)
{
v1 = v2;
v2 = vertices[i+1] - vertices[i];
determinant = calculate_determinant_2x2(v1.x, v1.y, v2.x, v2.y);
//you use the determinant to check direction from one point to another. A convex shape's points should only go around in one direction. The sign of the determinant determines that direction. If the sign of the determinant changes mid-way, then you have a concave shape.
if (referenceDeterminant * determinant < 0.0f)
{
//if multiplying two determinants result to a negative value, you know that the sign of both numbers differ, hence it is concave
return NO;
}
}
v1 = v2;
v2 = vertices[0]-vertices[count-1];
determinant = calculate_determinant_2x2(v1.x, v1.y, v2.x, v2.y);
if (referenceDeterminant * determinant < 0.0f)
{
return NO;
}
return YES;
}

// Comment these out from the draw method
ccDrawLine(_startPoint, _endPoint);
world->DrawDebugData();

// Add inside the init method
[self initBackground];

// Add this method
-(void)initBackground
{
CGSize screen = [[CCDirector sharedDirector] winSize];
CCSprite *background = [CCSprite spriteWithFile:@"bg.png"];
background.position = ccp(screen.width/2,screen.height/2);
[self addChild:background z:0];
}

// Replace everything starting from glDisableClientState in the draw method with this
CC_NODE_DRAW_SETUP();

ccGLBlendFunc( CC_BLEND_SRC, CC_BLEND_DST );

ccGLBindTexture2D( [_texture name] );
glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, sizeof(vertices[0]), vertices);
glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, sizeof(coordinates[0]), coordinates);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 2*[path count]-2);

// Add inside the initWithMaximumPoint method
self.shaderProgram = [[CCShaderCache sharedShaderCache] programForKey:kCCShader_PositionTexture];

// Remove from the setWidth method
* CC_CONTENT_SCALE_FACTOR()

// Remove from the push method
if (CC_CONTENT_SCALE_FACTOR() != 1.0f) {
v = ccpMult(v, CC_CONTENT_SCALE_FACTOR());
}

@property(nonatomic,retain)NSMutableArray *path;

@synthesize path;

// Add to top of file
#import "CCBlade.h"

// Add inside the @interface
CCArray *_blades;
CCBlade *_blade;
float _deltaRemainder;

// Add after the @interface
@property(nonatomic,retain)CCArray *blades;

// Add inside the @implementation
@synthesize blades = _blades;

// Add inside dealloc
[_blades release];
_blades = nil;

// Add inside init, after _raycastCallback
_deltaRemainder = 0.0;
_blades = [[CCArray alloc] initWithCapacity:3];
CCTexture2D *texture = [[CCTextureCache sharedTextureCache] addImage:@"streak.png"];

for (int i = 0; i < 3; i++)
{
CCBlade *blade = [CCBlade bladeWithMaximumPoint:50];
blade.autoDim = NO;
blade.texture = texture;

[self addChild:blade z:2];
[_blades addObject:blade];
}

// Add inside update, right after [self checkAndSliceObjects]
if ([_blade.path count] > 3) {
_deltaRemainder+=dt*60*1.2;
int pop = (int)roundf(_deltaRemainder);
_deltaRemainder-=pop;
[_blade pop:pop];
}

// Add inside ccTouchesBegan
CCBlade *blade;
CCARRAY_FOREACH(_blades, blade)
{
if (blade.path.count == 0)
{
_blade = blade;
[_blade push:location];
break;
}
}

// Add inside ccTouchesMoved
[_blade push:location];

// Add inside ccTouchesEnded
[_blade dim:YES];