#import "CCNode.h"
#import "Box2D.h"
 
typedef struct {
    GLfloat x;
    GLfloat y;
} Vertex2D;
 
static inline Vertex2D Vertex2DMake(GLfloat inX, GLfloat inY) {
    Vertex2D ret;
    ret.x = inX;
    ret.y = inY;
    return ret;
}
 
#define NUM_SEGMENTS 20
 
@interface MyNode : CCNode {
    // Texture
    CCTexture2D *texture;
 
    // Physics bodies
    NSMutableArray *bodies;
    float deltaAngle;
 
    // Center circle
    b2Body *innerCircleBody;
 
    // Polygon vertices
    Vertex2D triangleFanPos[NUM_SEGMENTS+2];
 
    // Texture coordinate array
    Vertex2D textCoords[NUM_SEGMENTS+2];
}
 
- (void) createPhysicsObject:(b2World*)world;
- (void) bounce;
 
@end

#import "cocos2d.h"
#import "MyNode.h"
 
#define PTM_RATIO 32.f
 
@implementation MyNode
 
- (id) init {
    self = [super init];
 
    texture = [[CCTextureCache sharedTextureCache] addImage:@"Ball.png"];        
 
    return self;
}
 
- (void) createPhysicsObject:(b2World *)world {
    // Center is the position of the circle that is in the center (inner circle)
    b2Vec2 center = b2Vec2(240/PTM_RATIO, 160/PTM_RATIO);
    b2CircleShape circleShape;
    circleShape.m_radius = 0.1f;
 
    b2FixtureDef fixtureDef;
    fixtureDef.shape = &circleShape;
    fixtureDef.density = 0.1;
    fixtureDef.restitution = 0.05;
    fixtureDef.friction = 1.0;
 
    // Delta angle to step by
    deltaAngle = (2.f * M_PI) / NUM_SEGMENTS;
 
    // Radius of the wheel
    float radius = 50;
 
    // Need to store the bodies so that we can refer back
    // to it when we connect the joints
    bodies = [[NSMutableArray alloc] init];
 
    for (int i = 0; i < NUM_SEGMENTS; i++) {
        // Current angle
        float theta = deltaAngle*i;
 
        // Calculate x and y based on theta
        float x = radius*cosf(theta);
        float y = radius*sinf(theta);
        // Remember to divide by PTM_RATIO to convert to Box2d coordinate
        b2Vec2 circlePosition = b2Vec2(x/PTM_RATIO, y/PTM_RATIO);
 
        b2BodyDef bodyDef;
        bodyDef.type = b2_dynamicBody;
        // Position should be relative to the center
        bodyDef.position = (center + circlePosition);
 
        // Create the body and fixture
        b2Body *body;
        body = world->CreateBody(&bodyDef);
        body->CreateFixture(&fixtureDef);
 
        // Add the body to the array to connect joints to it
        // later. b2Body is a C++ object, so must wrap it
        // in NSValue when inserting into it NSMutableArray
        [bodies addObject:[NSValue valueWithPointer:body]];
    }
 
    // Circle at the center (inner circle)
    b2BodyDef innerCircleBodyDef;
    // Make the inner circle larger
    circleShape.m_radius = 0.8f;
    innerCircleBodyDef.type = b2_dynamicBody;
 
    // Position is at the center
    innerCircleBodyDef.position = center;
    innerCircleBody = world->CreateBody(&innerCircleBodyDef);
    innerCircleBody->CreateFixture(&fixtureDef);
 
    // Connect the joints
    b2DistanceJointDef jointDef;
    for (int i = 0; i < NUM_SEGMENTS; i++) {
        // The neighbor
        const int neighborIndex = (i + 1) % NUM_SEGMENTS;
 
        // Get current body and neighbor
        b2Body *currentBody = (b2Body*)[[bodies objectAtIndex:i] pointerValue];
        b2Body *neighborBody = (b2Body*)[[bodies objectAtIndex:neighborIndex] pointerValue];
 
        // Connect the outer circles to each other
        jointDef.Initialize(currentBody, neighborBody,
                            currentBody->GetWorldCenter(), 
                            neighborBody->GetWorldCenter() );
        // Specifies whether the two connected bodies should collide with each other
        jointDef.collideConnected = true;
        jointDef.frequencyHz = 0.0f;
        jointDef.dampingRatio = 0.0f;
 
        world->CreateJoint(&jointDef);
 
        // Connect the center circle with other circles        
        jointDef.Initialize(currentBody, innerCircleBody, currentBody->GetWorldCenter(), center);
        jointDef.collideConnected = true;
        jointDef.frequencyHz = 8.0;
        jointDef.dampingRatio = 0.5;
 
        world->CreateJoint(&jointDef);
    }
}
 
 
 
- (void) draw {
    // Using the wheel defined by the box2d objects, we'll be mapping a circle on
    // top of it using a triangle fan. First, we calculate the center. The center
    // needs to be mulitplied by the PTM_RATIO (to get the pixel coordinate from box2d coordinate)
    // and also must be offset by the current position (remember, in HelloWorldLayer, we set
    // the position to the center of the screen (myNode.position = ccp(240, 160).
    triangleFanPos[0] = Vertex2DMake(innerCircleBody->GetPosition().x * PTM_RATIO - self.position.x, 
                                     innerCircleBody->GetPosition().y * PTM_RATIO - self.position.y);
    // Use each box2d body as a vertex and calculate coordinate for the triangle fan
    for (int i = 0; i < NUM_SEGMENTS; i++) {
        b2Body *currentBody = (b2Body*)[[bodies objectAtIndex:i] pointerValue];
        Vertex2D pos = Vertex2DMake(currentBody->GetPosition().x * PTM_RATIO - self.position.x, 
                                    currentBody->GetPosition().y * PTM_RATIO - self.position.y);
        triangleFanPos[i+1] = Vertex2DMake(pos.x, pos.y);
    }
    // Loop back to close off the triangle fan
    triangleFanPos[NUM_SEGMENTS+1] = triangleFanPos[1];
 
    // The first vertex is the center of the triangle fan.
    // So the first coordinate of the texture map should
    // map to the center of the triangle fan. The texture
    // map coordinates are normalized between 0 and 1, so
    // the center is (0.5, 0.5)
    textCoords[0] = Vertex2DMake(0.5f, 0.5f);
    for (int i = 0; i < NUM_SEGMENTS; i++) {
 
        GLfloat theta = M_PI + (deltaAngle * i);
 
        // Calculate the X and Y coordinates for texture mapping.
        // Need to normalize the cosine and sine functions so that the
        // values are between 0 and 1. Cosine and sine functions have
        // values from -1 to 1, so we divide by 2 and add 0.5 to it to
        // normalize the values between 0 and 1.
        textCoords[i+1] = Vertex2DMake(0.5+cosf(theta)*0.5, 
                                       0.5+sinf(theta)*0.5);
 
    }
    // Close it off.
    textCoords[NUM_SEGMENTS+1] = textCoords[1];
 
    // Enable texture mapping stuff
    glEnable(GL_TEXTURE_2D);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glDisableClientState(GL_COLOR_ARRAY);
 
    // Bind the OpenGL texture
    glBindTexture(GL_TEXTURE_2D, [texture name]);
 
    // Send the texture coordinates to OpenGL
    glTexCoordPointer(2, GL_FLOAT, 0, textCoords);
    // Send the polygon coordinates to OpenGL
    glVertexPointer(2, GL_FLOAT, 0, triangleFanPos);
    // Draw it 
    glDrawArrays(GL_TRIANGLE_FAN, 0, NUM_SEGMENTS+2);
 
    glEnableClientState(GL_COLOR_ARRAY);
}
 
- (void) bounce {
    b2Vec2 impulse = b2Vec2(innerCircleBody->GetMass() * 0, innerCircleBody->GetMass() * 40);
    b2Vec2 impulsePoint = innerCircleBody->GetPosition();
    innerCircleBody->ApplyLinearImpulse(impulse, impulsePoint);	          
}
 
@end

#import "CCNode.h"
 
typedef struct {
    GLfloat x;
    GLfloat y;
} Vertex2D;
 
static inline Vertex2D Vertex2DMake(GLfloat inX, GLfloat inY) {
    Vertex2D ret;
    ret.x = inX;
    ret.y = inY;
    return ret;
}
 
@interface MyNode : CCNode {
    Vertex2D vertices[4];   // For the polygon
    Vertex2D textCoords[4]; // For the texture
 
    CCTexture2D *texture;
}
@end

#import "cocos2d.h"
#import "MyNode.h"
 
@implementation MyNode
 
- (id) init {
    self = [super init];
 
    // Load the texture
    texture = [[CCTextureCache sharedTextureCache] addImage:@"Kirby.png"];        
 
    GLfloat size = [texture pixelsWide]/2;
 
    // Vertices for the square (we'll be using a triangle strip)
    vertices[0] = Vertex2DMake(-size, size);
    vertices[1] = Vertex2DMake(size, size);
    vertices[2] = Vertex2DMake(-size, -size);
    vertices[3] = Vertex2DMake(size, -size);
 
    // Because the texture is flipped about its x-axis,
    // we flip the y coordinates to correct this.
    textCoords[0] = Vertex2DMake(0, 0);
    textCoords[1] = Vertex2DMake(1, 0);
    textCoords[2] = Vertex2DMake(0, 1);
    textCoords[3] = Vertex2DMake(1, 1);
 
    // If you use the mapping below, then the image will
    // be flipped. To correct this, use the coordinates
    // above, or save the image in a flipped state so it
    // will be unflipped when mapped!
    /*
    textCoords[0] = Vertex2DMake(0, 1);
    textCoords[1] = Vertex2DMake(1, 1);
    textCoords[2] = Vertex2DMake(0, 0);
    textCoords[3] = Vertex2DMake(1, 0);
     */
 
    return self;
}
 
- (void) draw {
    // Following two states must be enabled for texture mapping
    glEnable(GL_TEXTURE_2D);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
    glDisableClientState(GL_COLOR_ARRAY);
 
    // Bind the OpenGL texture
    glBindTexture(GL_TEXTURE_2D, [texture name]);
 
    // The vertices for the polygon
    glVertexPointer(2, GL_FLOAT, 0, vertices);
    // The vertices for the texture
    glTexCoordPointer(2, GL_FLOAT, 0, textCoords);
    // Send it off to OpenGL
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 
    // Re-enable states
    glEnableClientState(GL_COLOR_ARRAY);
}
@end

- (void) bounce {
    b2Vec2 impulse = b2Vec2(innerCircleBody->GetMass() * 0, innerCircleBody->GetMass() * 150);
    b2Vec2 impulsePoint = innerCircleBody->GetPosition();
    innerCircleBody->ApplyLinearImpulse(impulse, impulsePoint);	        
}

- (void) draw {
    // Using the wheel defined by the box2d objects, we'll be mapping a circle on
    // top of it using a triangle fan. First, we calculate the center. The center
    // needs to be mulitplied by the PTM_RATIO (to get the pixel coordinate from box2d coordinate)
    // and also must be offset by the current position (remember, in HelloWorldLayer, we set
    // the position to the center of the screen (myNode.position = ccp(240, 160).
    triangleFanPos[0] = Vertex2DMake(innerCircleBody->GetPosition().x * PTM_RATIO - self.position.x, 
                                     innerCircleBody->GetPosition().y * PTM_RATIO - self.position.y);
 
 
    // Use each box2d body as a vertex and calculate coordinate for the triangle fan
    for (int i = 0; i < NUM_SEGMENTS; i++) {
        b2Body *currentBody = (b2Body*)[[bodies objectAtIndex:i] pointerValue];
        Vertex2D pos = Vertex2DMake(currentBody->GetPosition().x * PTM_RATIO - self.position.x, 
                                    currentBody->GetPosition().y * PTM_RATIO - self.position.y);
        triangleFanPos[i+1] = Vertex2DMake(pos.x, pos.y);
    }
 
    // Loop back to close off the triangle fan
    triangleFanPos[NUM_SEGMENTS+1] = triangleFanPos[1];
 
    // Disable the states. We're not texturing mapping just yet.
    glDisable(GL_TEXTURE_2D);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    glDisableClientState(GL_COLOR_ARRAY);
 
    // Set the color to red
    glColor4f(1.f, 0.f, 0.f, 1.f);
 
    glVertexPointer(2, GL_FLOAT, 0, triangleFanPos);
    // Number of vertices is NUM_SEGMENTS+2 because we have the origin
    // plus the loop back to close off the triangle fan
    glDrawArrays(GL_TRIANGLE_FAN, 0, NUM_SEGMENTS+2);
 
    // Re-enable states
    glEnableClientState(GL_COLOR_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glEnable(GL_TEXTURE_2D);
}

// MyNode is the squishy physics
MyNode *node = [MyNode node];
node.position = ccp(240, 160);
[node createPhysicsObject:world];
[self addChild:node];

#import "CCNode.h"
#import "Box2D.h"
 
typedef struct {
    GLfloat x;
    GLfloat y;
} Vertex2D;
 
static inline Vertex2D Vertex2DMake(GLfloat inX, GLfloat inY) {
    Vertex2D ret;
    ret.x = inX;
    ret.y = inY;
    return ret;
}
 
@interface MyNode : CCNode {
}
 
- (void) createPhysicsObject:(b2World*)world;
@end

#import "cocos2d.h"
#import "MyNode.h"
 
#define PTM_RATIO 32.f
 
@implementation MyNode
 
- (id) init {
    self = [super init];   
 
    return self;
}
 
// The number of outer circles (more, the smoother the circle)
#define NUM_SEGMENTS 12
 
- (void) createPhysicsObject:(b2World *)world {
    // Center is the position of circle that is in the center
    b2Vec2 center = b2Vec2(240/PTM_RATIO, 260/PTM_RATIO);
 
    b2CircleShape circleShape;
    circleShape.m_radius = 0.25f;
 
    b2FixtureDef fixtureDef;
    fixtureDef.shape = &circleShape;
    fixtureDef.density = 0.1;
    fixtureDef.restitution = 0.05;
    fixtureDef.friction = 1.0;
 
    // The greater the number, the more springy
    float springiness = 4.0;
 
    // Delta angle to step by
    float deltaAngle = (2.f * M_PI) / NUM_SEGMENTS;
 
    // Radius of the wheel
    float radius = 50;
 
    // Need to store the bodies so that we can refer back
    // to it when we connect the joints
    NSMutableArray *bodies = [NSMutableArray array];
 
    // For each segment...
    for (int i = 0; i < NUM_SEGMENTS; i++) {
        // Current angle
        float theta = deltaAngle*i;
 
        // Calcualte the x and y based on theta 
        float x = radius*cosf(theta);
        float y = radius*sinf(theta);
 
        // Remember to divide by PTM_RATIO to convert to Box2d coordinates
        b2Vec2 circlePosition = b2Vec2(x/PTM_RATIO, y/PTM_RATIO);
 
        b2BodyDef bodyDef;
        bodyDef.type = b2_dynamicBody;
        // Position should be relative to the center
        bodyDef.position = (center + circlePosition);
 
        // Create the body and fixture
        b2Body *body;
        body = world->CreateBody(&bodyDef);
        body->CreateFixture(&fixtureDef);
 
        // Add the body to the array to connect joints to it
        // later. b2Body is a C++ object, so must wrap it
        // in NSValue when inserting into it NSMutableArray
        [bodies addObject:[NSValue valueWithPointer:body]];
    }
 
    // Circle at the center (inner circle)
    b2BodyDef innerCircleBodyDef;
    innerCircleBodyDef.type = b2_dynamicBody;    
    // Position is at the center
    innerCircleBodyDef.position = center;    
    b2Body *innerCircleBody = world->CreateBody(&innerCircleBodyDef);
    innerCircleBody->CreateFixture(&fixtureDef);
 
    // Connect the joints    
    b2DistanceJointDef jointDef;
    for (int i = 0; i < NUM_SEGMENTS; i++) {
        // The neighbor.
        int neighborIndex = (i + 1) % NUM_SEGMENTS;
 
        // Get the current body and the neighbor
        b2Body *currentBody = (b2Body*)[[bodies objectAtIndex:i] pointerValue];
        b2Body *neighborBody = (b2Body*)[[bodies objectAtIndex:neighborIndex] pointerValue];
 
        // Connect the outer circles to each other
        jointDef.Initialize(currentBody, neighborBody,
                            currentBody->GetWorldCenter(), 
                            neighborBody->GetWorldCenter() );
        jointDef.collideConnected = true;
        jointDef.frequencyHz = springiness;
        jointDef.dampingRatio = 0.5f;
 
        world->CreateJoint(&jointDef);
 
        // Connect the center circle with other circles        
        jointDef.Initialize(currentBody, innerCircleBody, currentBody->GetWorldCenter(), center);
        jointDef.collideConnected = true;
        jointDef.frequencyHz = springiness;
        jointDef.dampingRatio = 0.5;
 
        world->CreateJoint(&jointDef);
    }
 
}
 
@end

mNode.position = ccp(100, 100)

MyNode *n = [MyNode node];
n.position = ccp(200, 200);
[self addChild:n];

#import "CCNode.h"
 
typedef struct {
    GLfloat x;
    GLfloat y;
} Vertex2D;
 
static inline Vertex2D Vertex2DMake(GLfloat inX, CGFloat inY) {
    Vertex2D ret;
    ret.x = inX;
    ret.y = inY;
    return ret;
}
@interface MyNode : CCNode {
    Vertex2D *vertices;
    float radius;
    int numSegments;
}

#import "MyNode.h"
#import "cocos2d.h"
 
@implementation MyNode
 
- (id) init {
    self = [super init];
    if (self) {
        // Radius of circle
        radius = 100;
 
        // Number segments of circle (bigger number, smoother circle)
        numSegments = 10;
 
        // Angle to step by
        float deltaAngle = 2 * M_PI / numSegments;
 
        // Allocate memory for vertices. We need 1 extra for the origin
        // and another for the end.
        vertices = (Vertex2D*) malloc(sizeof(Vertex2D) * (numSegments+1+2));
 
        // The origin vertex
        vertices[0] = Vertex2DMake(0, 0);
 
        for (int i = 1; i <= numSegments; i++) {
            GLfloat theta = deltaAngle*(i-1);
 
            // Calculate x and y based on theta
            GLfloat x = radius * cosf(theta);
            GLfloat y = radius * sinf(theta);
 
            vertices[i] = Vertex2DMake(x, y);
        }
 
        // Close it off
        vertices[numSegments+1] = vertices[1];
 
    }
    return self;
 
}
 
 
 
- (void) draw {
    [super draw];
 
    // Disable these states before drawing else you won't see anything
    glDisable(GL_TEXTURE_2D);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    glDisableClientState(GL_COLOR_ARRAY);
 
    // Set the color
    glColor4f(1.0, 0.0, 0.0, 1.0);
 
    // First argument - 2 numbers per Vertex2D (x and y)
    // Second argument - data type
    // Third argument - stride (ignore for now)
    // Fourth argument - pass the vertices
    glVertexPointer(2, GL_FLOAT, 0, vertices);
 
    // Last argument - total number of vertices
    glDrawArrays(GL_TRIANGLE_FAN, 0, (numSegments+2));
 
    // Renable disabled states
    glEnableClientState(GL_COLOR_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glEnable(GL_TEXTURE_2D);
}
@end

CCSprite *sprite = [CCSprite spriteWithSpriteFrameName@"oldImage.png"];
[sprite setDisplayFrame:[[CCSpriteFrameCache sharedSpriteFrameCache] spriteFrameByName:@"newImage.png"]];

#define CATEGORY_PLAYER    0x0001     // 0000 0000 0000 0001
#define CATEGORY_ENEMY     0x0002     // 0000 0000 0000 0010
#define CATEGORY_POWERUP   0x0004     // 0000 0000 0000 0100

b2FixtureDef playerFixture;
... 
playerFixture.filter.categoryBits = CATEGORY_PLAYER;
playerFixture.filter.maskBits = CATEGORY_ENEMY | CATEGORY_POWERUP;

b2FixtureDef powerupFixture;
... 
powerupFixture.filter.categoryBits = CATEGORY_POWERUP;
powerupFixture.filter.maskBits = CATEGORY_PLAYER;

b2FixtureDef enemyFixture;
... 
enemyFixture.filter.categoryBits = CATEGORY_ENEMY;
enemyFixture.filter.maskBits = CATEGORY_PLAYER;

uint16 catA = fixtureA.filter.categoryBits;
uint16 maskA = fixtureA.filter.maskBits;
uint16 catB = fixtureB.filter.categoryBits;
uint16 maskB = fixtureB.filter.maskBits;
 
if ((catA & maskB) != 0 && (catB & maskA) != 0) {
    // fixtures can collide
}

playerDef.categoryBits = CATEGORY_PLAYER;
playerDef.maskBits = CATEGORY_ENEMY;  // <-- point to the enemy
 
enemyDef.categoryBits = CATEGORY_ENEMY;
enemyDef.maskBits = CATEGORY_PLAYER;  // <-- point to the player

[CCTexture2D setDefaultAlphaPixelFormat:kTexture2DPixelFormat_RGBA4444];
// Available textures 
// kCCTexture2DPixelFormat_RGBA8888 - 32-bit texture with Alpha channel
// kCCTexture2DPixelFormat_RGB565 - 16-bit texture without Alpha channel
// kCCTexture2DPixelFormat_A8 - 8-bit textures used as masks
// kCCTexture2DPixelFormat_I8 - 8-bit intensity texture
// kCCTexture2DPixelFormat_AI88 - 16-bit textures used as masks
// kCCTexture2DPixelFormat_RGBA4444 - 16-bit textures: RGBA4444
// kCCTexture2DPixelFormat_RGB5A1 - 16-bit textures: RGB5A1
// kCCTexture2DPixelFormat_PVRTC4 - 4-bit PVRTC-compressed texture: PVRTC4
// kCCTexture2DPixelFormat_PVRTC2 - 2-bit PVRTC-compressed texture: PVRTC2

CCTexture2D *tex = [[CCTextureCache sharedTextureCache] addImage:@"MyAtlas.pvr"];
[[CCSpriteFrameCache sharedSpriteFrameCache] addSpriteFramesWithFile:@"MyAtlas.plist" texture:tex];

// GameObject.h
#import "cocos2d.h"
#import "Constants.h"
 
@interface GameObject : CCSprite {
    GameObjectType  type;
}
 
@property (nonatomic, readwrite) GameObjectType type;
@end
 
////////////////////////////////////////////////////////
 
// GameObject.m
@implementation GameObject
@synthesize type;
 
- (id)init
{
    self = [super init];
    if (self) {
        type = kGameObjectNone;
    }
 
    return self;
}
 
- (void)dealloc
{
    [super dealloc];
}
@end

// Player.h
#import "cocos2d.h"
#import "Box2D.h"
#import "GameObject.h"
 
@interface Player : GameObject {
    b2Body          *body;
}
 
-(void) createBox2dObject:(b2World*)world;
-(void) jump;
-(void) moveRight;
 
@property (nonatomic, readwrite) b2Body *body;
@end
 
///////////////////////////////////////////////////////
 
// Player.mm
#import "Player.h"
#import "Constants.h"
 
@implementation Player
@synthesize body;
 
- (id) init {
	if ((self = [super init])) {
		type = kGameObjectPlayer;
	}
	return self;
}
 
-(void) createBox2dObject:(b2World*)world {
    b2BodyDef playerBodyDef;
	playerBodyDef.type = b2_dynamicBody;
	playerBodyDef.position.Set(self.position.x/PTM_RATIO, self.position.y/PTM_RATIO);
	playerBodyDef.userData = self;
	playerBodyDef.fixedRotation = true;
 
	body = world->CreateBody(&playerBodyDef);
 
	b2CircleShape circleShape;
	circleShape.m_radius = 0.7;
	b2FixtureDef fixtureDef;
	fixtureDef.shape = &circleShape;
	fixtureDef.density = 1.0f;
	fixtureDef.friction = 1.0f;
	fixtureDef.restitution =  0.0f;
	body->CreateFixture(&fixtureDef);
}
 
-(void) moveRight {
    b2Vec2 impulse = b2Vec2(7.0f, 0.0f);
    body->ApplyLinearImpulse(impulse, body->GetWorldCenter());		
}
 
-(void) jump {
    b2Vec2 impulse = b2Vec2(4.0f, 15.0f);
    body->ApplyLinearImpulse(impulse, body->GetWorldCenter());		    
}
@end

// GameScene.mm
-(BOOL) ccTouchBegan:(UITouch *)touch withEvent:(UIEvent *)event {    
    CGPoint location = [touch locationInView:[touch view]];
    location = [[CCDirector sharedDirector] convertToGL:location];
    if (location.x <= screenSize.width / 2) {
        [player moveRight];        
    } else {
        [player jump];
    }
    return TRUE;
}
 
-(void) ccTouchEnded:(UITouch *)touch withEvent:(UIEvent *)event {
    CCLOG(@"Touch ended");
}

-(void) moveRight {
    b2Vec2 impulse = b2Vec2(7.0f, 0.0f);
    body->ApplyLinearImpulse(impulse, body->GetWorldCenter());		
}
 
-(void) jump {
    b2Vec2 impulse = b2Vec2(4.0f, 15.0f);
    body->ApplyLinearImpulse(impulse, body->GetWorldCenter());		    
}

// ContactListener.h
#import "Box2D.h"
 
class ContactListener : public b2ContactListener {
public:
	ContactListener();
	~ContactListener();
 
	virtual void BeginContact(b2Contact *contact);
	virtual void EndContact(b2Contact *contact);
	virtual void PreSolve(b2Contact *contact, const b2Manifold *oldManifold);
	virtual void PostSolve(b2Contact *contact, const b2ContactImpulse *impulse);
};
 
/////////////////////////////
 
// ContactListener.mm
#import "ContactListener.h"
#import "Constants.h"
#import "GameObject.h"
 
#define IS_PLAYER(x, y)         (x.type == kGameObjectPlayer || y.type == kGameObjectPlayer)
#define IS_PLATFORM(x, y)       (x.type == kGameObjectPlatform || y.type == kGameObjectPlatform)
 
 
ContactListener::ContactListener() {
}
 
ContactListener::~ContactListener() {
}
 
void ContactListener::BeginContact(b2Contact *contact) {
	GameObject *o1 = (GameObject*)contact->GetFixtureA()->GetBody()->GetUserData();
	GameObject *o2 = (GameObject*)contact->GetFixtureB()->GetBody()->GetUserData();
 
	if (IS_PLATFORM(o1, o2) && IS_PLAYER(o1, o2)) {
        CCLOG(@"-----> Player made contact with platform!");
    }
}
 
void ContactListener::EndContact(b2Contact *contact) {
	GameObject *o1 = (GameObject*)contact->GetFixtureA()->GetBody()->GetUserData();
	GameObject *o2 = (GameObject*)contact->GetFixtureB()->GetBody()->GetUserData();
 
	if (IS_PLATFORM(o1, o2) && IS_PLAYER(o1, o2)) {
        CCLOG(@"-----> Player lost contact with platform!");
    }
}
 
void ContactListener::PreSolve(b2Contact *contact, const b2Manifold *oldManifold) {
}
 
void ContactListener::PostSolve(b2Contact *contact, const b2ContactImpulse *impulse) {
}

 contactListener = new ContactListener();
 world->SetContactListener(contactListener);

// GameScene.h
 
#import "cocos2d.h"
#import "Box2D.h"
#import "GLES-Render.h"
#import "ContactListener.h"
 
@class Player;
 
@interface GameScene : CCLayer
{
    CGSize screenSize;
	b2World* world;
	GLESDebugDraw *m_debugDraw;
	CCTMXTiledMap *tileMapNode;	
    Player *player;
    ContactListener *contactListener;
}
 
+(id) scene;
@end
 
///////////////////////////////////////////////
 
// GameScene.mm
#import "GameScene.h"
#import "Constants.h"
#import "Player.h"
#import "GameObject.h"
 
@interface GameScene(Private) 
-(void) setupPhysicsWorld;
@end
 
@implementation GameScene
 
+(id) scene
{
	// 'scene' is an autorelease object.
	CCScene *scene = [CCScene node];
 
	// 'layer' is an autorelease object.
	GameScene *layer = [GameScene node];
 
	// add layer as a child to scene
	[scene addChild: layer];
 
	// return the scene
	return scene;
}
 
- (void) makeBox2dObjAt:(CGPoint)p 
			   withSize:(CGPoint)size 
				dynamic:(BOOL)d 
			   rotation:(long)r 
			   friction:(long)f 
				density:(long)dens 
			restitution:(long)rest 
				  boxId:(int)boxId {
 
	// Define the dynamic body.
	//Set up a 1m squared box in the physics world
	b2BodyDef bodyDef;
//	bodyDef.angle = r;
 
	if(d)
		bodyDef.type = b2_dynamicBody;
 
	bodyDef.position.Set(p.x/PTM_RATIO, p.y/PTM_RATIO);
 
    GameObject *platform = [[GameObject alloc] init];
    [platform setType:kGameObjectPlatform];
	bodyDef.userData = platform;
 
	b2Body *body = world->CreateBody(&bodyDef);
 
	// Define another box shape for our dynamic body.
	b2PolygonShape dynamicBox;
	dynamicBox.SetAsBox(size.x/2/PTM_RATIO, size.y/2/PTM_RATIO);
 
	// Define the dynamic body fixture.
	b2FixtureDef fixtureDef;
	fixtureDef.shape = &dynamicBox;	
	fixtureDef.density = dens;
	fixtureDef.friction = f;
	fixtureDef.restitution = rest;
	body->CreateFixture(&fixtureDef);
}
 
 
 
- (void) drawCollisionTiles {
	CCTMXObjectGroup *objects = [tileMapNode objectGroupNamed:@"Collision"];
	NSMutableDictionary * objPoint;
 
	int x, y, w, h;	
	for (objPoint in [objects objects]) {
		x = [[objPoint valueForKey:@"x"] intValue];
		y = [[objPoint valueForKey:@"y"] intValue];
		w = [[objPoint valueForKey:@"width"] intValue];
		h = [[objPoint valueForKey:@"height"] intValue];	
 
		CGPoint _point=ccp(x+w/2,y+h/2);
		CGPoint _size=ccp(w,h);
 
		[self makeBox2dObjAt:_point 
					withSize:_size 
					 dynamic:false 
					rotation:0 
					friction:1.5f 
					 density:0.0f 
				 restitution:0 
					   boxId:-1];
	}
}
 
- (void) addScrollingBackgroundWithTileMap {
	tileMapNode = [CCTMXTiledMap tiledMapWithTMXFile:@"scroller.tmx"];
	tileMapNode.anchorPoint = ccp(0, 0);
	[self addChild:tileMapNode];
}
 
 
// initialize your instance here
-(id) init
{
	if( (self=[super init])) {
 
		// enable touches
		self.isTouchEnabled = YES;
 
		screenSize = [CCDirector sharedDirector].winSize;
		[[CCTouchDispatcher sharedDispatcher] addTargetedDelegate:self priority:0 swallowsTouches:YES];   
 
		[self setupPhysicsWorld];
 
		[self addScrollingBackgroundWithTileMap];
		[self drawCollisionTiles];
 
		player = [Player spriteWithFile:@"Icon-Small.png"];        
		player.position = ccp(100.0f, 180.0f);
		[player createBox2dObject:world];
 
		[self addChild:player];
 
        // Start main game loop
		[self scheduleUpdate];
	}
	return self;
}
 
-(void) setupPhysicsWorld {
    b2Vec2 gravity = b2Vec2(0.0f, -9.8f);
    bool doSleep = true;
    world = new b2World(gravity, doSleep);
 
    m_debugDraw = new GLESDebugDraw(PTM_RATIO);
    world->SetDebugDraw(m_debugDraw);
    uint32 flags = 0;
    flags += b2DebugDraw::e_shapeBit;
    m_debugDraw->SetFlags(flags);
 
    contactListener = new ContactListener();
    world->SetContactListener(contactListener);
}
 
-(void) draw {
	glDisable(GL_TEXTURE_2D);
	glDisableClientState(GL_COLOR_ARRAY);
	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 
	world->DrawDebugData();
 
	// restore default GL states
	glEnable(GL_TEXTURE_2D);
	glEnableClientState(GL_COLOR_ARRAY);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
 
- (void) update:(ccTime)dt {
	//It is recommended that a fixed time step is used with Box2D for stability
	//of the simulation, however, we are using a variable time step here.
	//You need to make an informed choice, the following URL is useful
	//http://gafferongames.com/game-physics/fix-your-timestep/
 
	int32 velocityIterations = 8;
	int32 positionIterations = 1;
 
	// Instruct the world to perform a single step of simulation. It is
	// generally best to keep the time step and iterations fixed.
	world->Step(dt, velocityIterations, positionIterations);
 
 
	//Iterate over the bodies in the physics world
	for (b2Body* b = world->GetBodyList(); b; b = b->GetNext()) {
		if (b->GetUserData() != NULL) {
			//Synchronize the AtlasSprites position and rotation with the corresponding body
			CCSprite *myActor = (CCSprite*)b->GetUserData();
			myActor.position = CGPointMake( b->GetPosition().x * PTM_RATIO, 
							b->GetPosition().y * PTM_RATIO);
			myActor.rotation = -1 * CC_RADIANS_TO_DEGREES(b->GetAngle());
		}	
	}	
 
	b2Vec2 pos = [player body]->GetPosition();
	CGPoint newPos = ccp(-1 * pos.x * PTM_RATIO + 50, self.position.y * PTM_RATIO);	
	[self setPosition:newPos];
}
 
-(BOOL) ccTouchBegan:(UITouch *)touch withEvent:(UIEvent *)event {    
    CGPoint location = [touch locationInView:[touch view]];
    location = [[CCDirector sharedDirector] convertToGL:location];
    if (location.x <= screenSize.width / 2) {
        [player moveRight];        
    } else {
        [player jump];
    }
	return TRUE;
}
 
// on "dealloc" you need to release all your retained objects
- (void) dealloc {
    // in case you have something to dealloc, do it in this method
 
    delete contactListener;
    delete world;
    world = NULL;
 
    delete m_debugDraw;
 
    // don't forget to call "super dealloc"
    [super dealloc];
}
@end