Zombie Games

• ZombieSmash $1.99
• Zombie Farm  $Free

Flying Hero Games

• The Hero $1.99
• Super Turbo Action Pig $0.99

Shooter Games

• AbstractWar 2.0 $0.99
• Sniper Strike $Free

Racing Games

• Doodle Kart $0.99
• Doodle Kart Lite $Free
• Sprint Racers GP $Free (link will be added soon)

Puzzle Games

• Tiki Totems $Free
• Tiki Totems Premium $1.99
• Blockoban $Free
• Blockoban Premium $2.99

Strategy Games

• Space Harvest $1.99
• Kretures $0.99
• Kretures Lite $Free

Artistic Games

• Trundle $Free
• Pixel Pile $0.99
• Forest Folk $1.99
• Zwirn $0.99
• Zwirn Lite $Free

Doodle/Stick Games

• Doodle Blast $0.99
• Stick Sports: Summer Games $1.99
• Stick Sports: Summer Games Lite $Free

Kids Games

• Zoo Lasso $0.99
• Monkey Preschool Lunchbox $0.99

To see more cocos2d games, please visit: Games powered by cocos2d

Previous posts about cocos2d games: More than 100 games using cocos2d, 3 games in the top 10

Cocos2d-iphone and Chipmunk

A while ago when I (MobileBros) was just beginning to use Cocos2d-iphone, I also started playing around with Chipmunk; at the time this was the only physics library that came with Cocos2d and I wasn’t really aware of anything else out there. Very quickly I discovered that I was writing a lot of repetitive code in order to use Chipmunk and what was more was that it was in C, making me have consider two languages now! Sound familar?

Chipmunk:
Chipmunk is actually very simple in concept. There is a chipmunk “space”, you add shapes/bodies/constraints to the space, you ask the space to simulate a specific amount of time. Thats it! The last step performs all the magic that is rigid-body physics.

Cocos2d Integration – Basic Approach:
Cocos2d is very good at a lot of things, its a very good at displaying sprites, particles, actions, touches, and a number of other things. Chipmunk is very good a simulating rigid-body physics. The common approach to “glueing” both components together usually involves running chipmunk and telling it to update Cocos2d nodes (setting position and rotation); pretty much a basic model-view approach. Modifying the constraints, and modifying collision behavior in the chipmunk system would result in different behavior; your game logic.

The SpaceManager attempts to step in as this glue and automate much of the process.

What is SpaceManager?

There are actually two distinct parts of the Chipmunk-SpaceManager project. There is the core SpaceManager class and then there are a number of “helper” classes targeting Cocos2d-iphone and used for representing shapes and constraints with CCNode types. In fact most people do not realize that these two parts are independent of each other.

Core:
The goal of the core SpaceManager class was to provide an encapsulation around the basic tasks we (at least) found ourselves performing over and over. Theses tasks included:

• making basic shapes (rects, circles, polys)
• removing shapes (especially a mechanism for during collisions)
• advancing time within the chipmunk space
• negligible API difference in Static and Active shapes
• updating our views with our “model” (Chipmunk –> Cocos2d)
• updating our model with our controller/view (Cocos2d –> Chipmunk)
• non invasive to chipmunk (you can combine native chipmunk calls with spacemanager calls)
• window containment walls (sounds dumb, but it’s tedious)

Our aim was not exactly to wrap exising objects and functionality (In fact slembcke just released an obj-c wrapper suite). Instead we wanted something to manage common tasks/patterns.

Cocos2d Helpers:
The goal of the “helper” classes was to provide a simple solution to associating a shape/constraint with a corresponding CCNode type. By doing this we could also accomplish a number of other common tasks including: automatic cleanup of shape/body from chipmunk upon node deletion, as well as being able to control the position and rotation of shapes thru CCAction's or even just calling setPosition or setRotation on the node.

cpShapeNode and cpConstraintNode are somewhat special in that they will draw their corresponding shape/constraint respectfully. For instance you just created a cpConstraintNode with a spring constraint, by adding this node type to a CCLayer or other CCNode it will correctly draw a spring constraint between the attached bodies (it uses OpenGL to draw a zig-zag line).

A base class called cpCCNode is provided for anyone wishing to derive their own class implementation. It provides:

• shape property: your associated shape
• integrationDt: if other than zero, any call to setPosition (not coming from chipmunk) will result in velocity being calculated
• spaceManager: a reference to the owning spaceManager
• autoFreeShape: cleanup the shape, needs the spaceManager property set
• applyImpulse: apply an impulse to the shape’s body
• applyForce: apply a continuous force to the shape’s body
• resetForces: reset any continuous forces to zero

Give me an Example!

Lets assume you are working on a CCLayer that you’ve just subclassed and want to integrate Chipmunk with. This layer will act as your space and any CCNodes added will represent your shapes and constraints.

First off, lets create our space and add a containment rect (so other shapes can’t go offscreen).

smgr = [[SpaceManager alloc] init];       //SpaceManager* smgr declared in header file
[smgr addWindowContainmentWithFriction:0.8 elasticity:0.7 inset:cpvzero];

Well it doesn’t look like much, but chipmunk was just initialized and a cpSpace was created and set up with default values and gravity. We then created a containment rect, thats somewhat bouncy with the friction coefficient of concrete, a concrete room if you will.

Our First Shape:
Well thats all well and good, but lets add a ball next; lets use a cpShapeNode (a “helper” class) for this example because it only uses OpenGL primative calls to draw itself.

cpShape *ball = [smgr addCircleAt:cpv(240,160) mass:5.0 radius:15];
 
ballNode = [cpShapeNode nodeWithShape:ball];       //cpShapeNode *ballNode declared in header file
ballNode.color = ccBLUE;
 
ballNode.autoFreeShape = YES;
ballNode.spaceManager = smgr;
 
[self addChild:ballNode];

We just asked the SpaceManager to create a circle shape for us, placed in the middle of the screen with a mass of 5 and a radius of 15; it gave us back a cpShape* which we then attached it to a cpShapeNode, colored it blue, and added to self (our CCLayer). Also important here is that we told the ballNode to auto-free it’s shape (when ballNode is released) and also who our SpaceManager instance was. This frees you from worrying about clean-up later.

Crank it up:
At this point, things are starting to sound interesting, however if you ran the code right now, you’d wonder why there is a blue circle just sitting in the middle of the screen. Oh yeah! We need to tell chipmunk to start simulating our space.

[smgr start:1.0/60.0];

Woo-Hoo! We did it, a blue ball should fall from the center of the screen and bounce up and down a few times on the bottom of the screen. Well ok, thats not very interesting is it.

Touches:
Perhaps we can make it do something in our touch methods. Don’t forget to set up your layer as a touch delegate…

-(BOOL) ccTouchBegan:(UITouch*)touch withEvent:(UIEvent*)event
{
   CGPoint pt = [self convertTouchToNodeSpace:touch];
 
   [ballNode applyImpulse:ccpMult(ccpSub(pt, ballNode.position), 3)];
 
   return YES;
}

This will give the ball a jolt in the direction you touch, stronger the further away you touch. Now if you only had a target to hit…. you’d have a game!

A Game Idea…
$1,000,000 Game Idea: A ball and a target; touch to launch the ball at the target; the less touches it takes to hit the target, the more points you get!

Ok so lets get a target going, perhaps a nice red square?

cpShape *target = [smgr addRectAt:cpv(440,160) mass:STATIC_MASS width:20 height:20 rotation:0];
 
targetNode = [cpShapeNode nodeWithShape:target];       //cpShapeNode *targetNode declared in header file
targetNode.color = ccRED;
 
targetNode.autoFreeShape = YES;
targetNode.spaceManager = smgr;
 
[self addChild:targetNode];

Nothing too dramatic here, EXCEPT whats this STATIC_MASS thing? Well in chipmunk terms STATIC_MASS == INFINITY, the former just seemed a little more definitive sounding. In chipmunk land there are shapes that are “active” and then there are shapes that are “static”, static shapes are never supposed to move; they are immovable as far as chipmunk sees things. Well what better use than for our target rectangle shape? Passing a STATIC_MASS for mass will make the SpaceManager perform the necessities it takes to set one up, everything else will look the same as when we created our ball above.

Collision Callbacks:
We now have a ball, touch logic, and a target. All we need now is to know when the target has been hit. First off, we need to define a method to handle this.

-(BOOL) handleCollision:(CollisionMoment)moment arbiter:(cpArbiter*)arb space:(cpSpace*)space
{
   if (moment == COLLISION_BEGIN)
   {
      CCLabel *label = [CCLabel labelWithString:@"You Win!" fontName:@"Helvetica" fontSize:32];
      label.position = ccp(240,160);
      label.color = ccBLACK;
      [self addChild:label];
}
 
//other moments: COLLISION_PRESOLVE, COLLISION_POSTSOLVE, COLLISION_SEPARATE
 
return YES;
}

If you’re familar with chipmunk callback functions, you’ll notice that this is slightly similar but you are now passed a CollisionMoment variable as well. This enum tells you what collision moment we are at, in this case we only care about when the objects first begin touching.

Now don’t forget…. we need to register this callback with our SpaceManager instance:

ballNode.shape->collision_type = 1;
targetNode.shape->collision_type = 2;
 
[smgr addCollisionCallbackBetweenType:1
                            otherType:2
                               target:self
                             selector:@selector(handleCollision:arbiter:space:)];

Thats it! If we just keep track of how many touches, perhaps display them too our game is all done. If anyone is interested in this example, the complete source is given here: SpaceManager Example

The SpaceManager can do a whole lot more than discussed here including: scheduling shapes for deletion, fragmenting shapes, morphing shapes between active and static, detecting persistent contacts, etc. The project web page can be found at http://code.google.com/p/chipmunk-spacemanager/ and a more in-depth example is included with the source code.

• Sprite Test: It tests the CCSprite and CCSpriteSheet functionality like anchorPoint, visibility, parenting, reordering, honor Transform, etc…
• Action Test: It tests the CCMove, CCRotate, CCTint, CCCamera, CCSequence, CCSpawn, etc..
• Menu Test: It tests all kind of menus
• CocosDenshion: It tests the Sound Engine
• Chipmunk Accel Touch Test: It tests integration with Chipmunk physics engine using accelerometer and multi touches.
• Particle Test: It tests all kind of particles (quad particles, point particles, sun, meteor, galaxy, smoke, fire, etc…)
• etc…

Although these tests were coded for testing purposes they can also be used as examples. Not only they use the API in the recommended way, but some of them, also contain useful tips in the commentaries.

In order to run the tests, you should do:

1. Open the cocos2d Xcode project
2. Select the test target: Xcode -> Project -> Set Active Target -> eg: TransitionTest
3. Make sure that the running executable is correct: Xcode -> Project -> Set Active Executable -> eg: TransitionTest
4. Build and run: Xcode -> Build and run

Another quick way of doing it by customizing the toolbar:

1. Xcode -> Right click on the toolbar -> Customize Toolbar
2. Drag & drop the Active Target button to the toolbar
3. Drag & drop the Active Executable button to the toolbar

The source code of the samples are in the tests subdirectory.

So, let’s say you want to learn how to use Tiled maps. What you should do is:

1. Select the TileMapTest target
2. Make sure that the TileMapTest executable is selected
3. Build & Run.
4. Try all the subtests. The TileMapTest has more than 10 subtests. Eg: Hexagonal test, Isometric test, Orthogonal tests, read-write tile tests, etc…
5. See the TileMapTest source code: tests/TileMapTest.m
6. Modify the source code and go to step 2.

Sometimes it is needed to hide certain images in your game from opportunists. One possible way of doing it, is to subclass CCTextureCache and override the addImage method.

For example:

//pseudo code
-(CCTexture2D*) addImage:(NSString*)path
{
   if( file_exists( path + ".enc" )  {
       mem = decrypt( path + ".enc", secretKey );
       uiimage = [[UIImage alloc] initWithData:mem];
       texture = [[CCTexture2D alloc] initWithImage:uiimage];
   }
}

Basically, if it finds an encrypted file, it will decrypt it with a secret key. So the .app bundle will have the crypted images, and opportunists won’t be able to look at them easily.

User mhussa created a sample project that includes these ideas. The project includes:

• CCEncryptedTextureCache.m (subclass of CCTextureCache )
• CryptUtils.cpp (helper functions to encrypt/decrypt files)
• The ‘Encrypt’ build phase: It encrypts files at build time. You don’t need to encrypt them manually!

To customize which files to encrypt, you have to edit the ‘Encrypt’ build phase:

• Xcode -> Targets -> CCRadialTransitionDemo -> Encrypt
• Right click over ‘Encrypt’ -> Get Info

For further info regarding mhussa’s implementation, please read: How to use CCEncryptedTextureCache

Download: Xcode CCEncryptedTextureCache project

Although it is possible to reuse the cocos2d v0.8 animation code, v0.99 introduces a new way to deal with animations (and sprites in general).

v0.99 has a new class named CCSpriteFrameCache that, as the name suggests, it is the cache of all the sprite frames.
You can load sprites frames to the CCSpriteFrameCache with:

• a plist filename (generated by Zwoptex editor)
• a plist filename (generated by Zwoptex editor) and a CCTexture2D
• a CCSpriteFrame and a sprite frame name

( See the full API here: CCSpriteFrameCache API )

And the CCSpriteFrame object has the following properties:

• a CCTexture2D: which texture should it use.
• a CGRect: the rectangle of the texture (from 1 texture you can create many CCSpriteFrame objects, in fact it is the recommend way to avoid wasting unnecessary memory).

Example:

// Obtain the shared instance of the cache
CCSpriteFrameCache *cache = [CCSpriteFrameCache sharedSpriteFrameCache;
 
// load the frames
[cache addSpriteFramesWithFile:@"frames.plist"];
 
// It loads the frame named "frame1.png".
// IMPORTANT: It doesn't load the image "frame1.png". "frama1.png" is a just the name of the frame
CCSpriteFrame *frame = [cache spriteFrameByName:@"frame1.png"];
[sprite setDisplayFrame:frame];

This was just an introduction to CCSpriteFrameCache.

For further info, please read

• hhamm’s Programming iPhone Games with Cocos2D Part 3
• cocos2d programming guide: Animations

This time, the article is about how to make a simple Breakout game.

• How to make a simple Breakout game Part 1/2
• How to make a simple Breakout game Part 2/2

The article includes:

• How to setup Box2d (gravity, bodies, etc…)
• How to handle collision detection in Box2d
• How to add and destroy Box2d bodies
• How to link a CCSprite with a Box2d body
• Uses touches to move the paddle
• Plays music and sound effects using CocosDenshion
• It has a You Win and a You lose scene
• The Xcode project

Also, cocos2d comes with 2 box2d examples:

• An accelerometer + multitouch box2d sample: Great sample for box2d newbies
• And the box2d testbed: targeting more advanced users

Recently, Ray Wenderlich also wrote an interesting article regarding how use box2d with cocos2d v0.99.0:

• Intro to Box2D with Cocos2D Tutorial: Bouncing Balls

• 123 days
• 94 closed issues
• 5 intermediate releases
• 329 commits

cocos2d for iPhone v0.99.0 was released!

Download: cocos2d-iphone-0.99.0.tar.gz

Release Notes: release_notes:0_99_0

Full Changelog: CHANGELOG

Many thanks to all the developers, contributors, beta testers, and the community in general. We are building a professional-grade library both in terms of technical features and support!

You can read the turorial from:

• Tutorial: Using Facebook Connect with cocos2d (Jeston’s homepage)
• or Tutorial: Using Facebook Connect with cocos2d (cocos2d forum)

The tutorial uses cocos2d v0.8.x, and it can easily be ported to cocos2d v0.99

Download: cocos2d-iphone-0.99.0-final.tar.gz

Release Notes: release_notes:0_99_0_final

Changelog: CHANGELOG

Highlights (from v0.99.0-rc):

• CocosDenshion: many fixes and improvements
• Fixed some crashes and other important fixes on: Sprites & TMX maps

Known bugs: known_bugs

How stable is this release ?
Very stable. According to the tests and feedback from the testers, this release can be considered v0.99.0. But since v0.99.0 introduces so many changes, this will the last pre-v0.99.0 release.

If there are no show-stoppers bugs, then, this will be the real v0.99.0 version.
No small fixes will be introduced unless they are show-stopper bugs.
Small fixes and improvements will be fixed during the v0.99.x series.

How fast is this release ?
All the performance tests were run, and v0.99.0-final is, at least, as fast as v0.8.2. In some cases it is faster, perhaps 10%~20% faster.

I would appreciate if you could test this release in your game. Please, report any bug that you might find.
Thanks!