Introduction
Have you ever imagined yourself writing a computer game and being able to make money selling it? With Apple’s iTunes App Store and the accompanying mobile iPhone, iPod touch, and iPad devices, doing that is now easier than ever. Of course, that doesn’t mean it’s easy—there’s still a lot to learn about game development and programming games. But you are reading this book, so I believe you’ve already made up your mind to take this journey. And you’ve chosen one of the most interesting game engines to work with: cocos2d for iOS.
Developers using cocos2d come from a huge variety of backgrounds. Some, like me, have been professional game developers for years, or even decades. Others are just starting to learn programming for iOS devices or are freshly venturing into the exciting field of game development. Whatever your background might be, I’m sure you’ll get something out of this book.
Two things unite all cocos2d developers: we love games, and we love creating and programming them. This book pays homage to that, yet doesn’t forget about the tools that help ease the development process. Most of all, you’ll be making games that matter along the way, and you’ll see how this knowledge is applied in real game development.
You see, I get bored by books that spend all their pages teaching me how to make yet another dull Asteroids clone using some specific game-programming API (application programming interface. What’s more important, I think, are game-programming concepts and tools—the things you take with you even as APIs or your personal programming preferences change. I’ve amassed hundreds of programming and game development books over 20 years. The books I value the most to this day are those that went beyond the technology and taught me why certain things are designed and programmed the way they are. This book will focus not just on working game code but also on why it works and which trade-offs to consider.
I would like you to learn how to write games that matter—games that are popular on the App Store and relevant to players. I’ll walk you through the ideas and technical concepts behind these games in this book and, of course, how cocos2d and Objective-C make these games tick. You’ll find that the source code that comes with the book is enriched with a lot of comments, which should help you navigate and understand all the nooks and crannies of the code.
Learning from someone else’s source code with a guide to help focus on what’s important is what works best for me whenever I’m learning something new—and I like to think it will work great for you too. And because you can base your own games on the book’s source code, I’m looking forward to playing your games in the near future! Don’t forget to let me know about them!
You can share your projects and ask questions on Cocos2D Central (www.cocos2d-central.com), and you can reach me at [email protected]. You should definitely visit the book’s companion web site at www.learn-cocos2d.com. Since the first edition of this book, I began improving cocos2d with the Kobold2D project, which you can also use while reading this book. You can learn more about Kobold2D by visiting www.kobold2d.com.
What’s New in the Third Edition?
This third edition is a complete overhaul to bring the book up to date with the latest developments, including but not limited to iOS 6 and Xcode 4.4.
For one, cocos2d 2.0 is fresh out of the box. All the source code and descriptions have been adapted to the latest incarnation of cocos2d and OpenGL ES 2.0. Although you cannot deploy cocos2d 2.0 apps on 1st- and 2nd-generation devices, in March 2012 these devices only made up about 16% of all iOS devices sold thus far. There’s no doubt that by the time you’re reading this book this number will have gone down to around 10% and be still falling as the newer devices continue to sell at an ever increasing rate.
I’ve also received plenty of questions from many readers all wanting to know the same thing: can the book be used with Kobold2D as well? Previously I had to say “Yes, but there are a few things that are slightly different.” The third edition changes my answer to a resounding “Yes, by all means!” Whenever there’s anything that works differently in Kobold2D, I mention that. I also highlight all the things that you don’t need to do anymore if you were using Kobold2D, because that’s what Kobold2D is all about: making cocos2d easier to use.
In case you passed on the second edition, here’s a quick recap of what was new in the second edition and was further adapted for this edition. First Andreas Löw joined as a co-author for the book, providing valuable help to improve the book with instructions for his Texture Packer and Physics Editor tools. Together we overhauled a lot of the graphics and significantly improved several chapters with additional code and new features. And two new chapters were added: one about integrating cocos2d in a UIKit app and the other an introduction to the (then newly released) Kobold2D.
All About ARC
Then there’s ARC. Woof? What? ARC? Yes, automatic reference counting (ARC) is Apple’s new and proven technology to simplify memory management for Objective-C applications. In essence it does away with reference counting, meaning you no longer have to concern yourself with remembering how many times you or other code has retained an object, requiring you to release it the exact same number of times. Autoreleasing objects further complicated that matter. If you didn’t get retain, release, and autorelease 100% matched up correctly every time for every object, you were either leaking memory or the app would be prone to crashing.
It’s also good to know that ARC is not garbage collection. It works fully deterministic, which means if you run the same program through the exact same process every time, it will behave exactly the same. ARC is also not a runtime component—it’s the compiler inserting retain, release, and autorelease statements automatically for you whenever they are needed. There is a set of simple rules followed by ARC that every Objective-C programmer previously had to follow to avoid memory leaks and crashes. You can imagine that if a human being does that job, a lot more errors sneak in, whereas ARC is not only able to perform this job without fail, it also optimizes your code along the way. For example, in manual reference counting you had the ability to retain objects multiple times. ARC, however, realizes when additional retains are unnecessary and omits them.
Now, the compiler has taken over the tedious job of retaining and releasing objects in memory, and all the source code throughout the book has been converted to use ARC. This means fewer code lines to write, and fewer potentially lethal drugs . . . err, bugs.
The two biggest concerns from Objective-C programmers towards ARC are loss of control and learning a new programming paradigm. Both are terrible arguments against using ARC. I offer an analogy: think of ARC being like automatic transmission in a car, and manual reference as shifting gears manually. If you leave the world of the clutch and gear stick, are you really giving up control? Yes, but it’s not control that you really need. Do you need to learn something new? No, you only need to unlearn a few things and you actually have to do less.
With manual transmission, you can easily miss a gear even after years of driving, possibly damaging the engine. That is equivalent to over-releasing or over-retaining an object. You may also kill the engine with the clutch every now and then. That’s the equivalent of crashing your app due to a dangling (over-released) pointer. And with an automatic transmission, the engine always changes gears at the optimal rate, typically reducing the fuel consumption rate to a comparable manually shifted car (and a typical driver). Wasting gas is the equivalent of leaking memory.
To sum it up: ARC does not take control away from you. You can still control everything that is important to your app. Code that requires more memory management control than is available to you under ARC does not exist. The issue of loss of control is purely psychological and possibly based on misconceptions about how ARC works. Which brings me to the learning aspect: yes, there are a few things you can and should learn about ARC. But this is so little compared to what a programmer learns every day, and it’s far easier than picking up (let alone mastering) manual reference counting if you’re new to Objective-C. You only need to read Apple’s relatively short Transitioning to ARC Release Notes summary: http://developer.apple.com/library/ios/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html. You may also want to read my blog post covering everything you need to know about automatic reference counting: www.learn-cocos2d.com/2011/11/everything-know-about-arc.
Why Use cocos2d for iOS?
When game developers look for a game engine, they first evaluate their options. I think cocos2d is a great choice for a lot of developers, for many reasons.
It’s Free
First, it is free. It doesn’t cost you a dime to work with it. You are allowed to create both free and commercial iPhone, iPod, and iPad apps. You can also create Mac OS X apps with it. You don’t have to pay any royalties. Seriously, no strings attached.
It’s Open Source
The next good reason to use cocos2d is that it’s open source. This means there’s no black box preventing you from learning from the game engine code or making changes to it where necessary. That makes cocos2d both extensible and flexible.
It’s Objective, See?
Cocos2d is written in Objective-C, Apple’s native programming language for writing iOS apps. It’s the same language used by the iOS SDK, which makes it easy to understand Apple’s documentation and implement iOS SDK functionality.
A lot of other useful APIs, such as Facebook Connect and OpenFeint, are also written in Objective-C, which makes it easy to integrate those APIs, too.
Note I advise learning Objective-C, even if you prefer some other language. I have a strong C++ and C# background, and the Objective-C syntax looked very odd at first glance. I wasn’t happy at the prospect of learning a new programming language that was said to be old and outdated. Not surprisingly, I struggled for a while to get the hang of writing code in a programming language that required me to let go of old habits and expectations.
Don’t let the thought of programming with Objective-C distract you, though. It does require some getting used to, but it pays off soon enough, if only for the sheer amount of documentation available. I promise you won’t look back!
It’s 2D
Of course, cocos2d carries the 2D in its name for a reason. It focuses on helping you create 2D games. It’s a specialization few other iOS game engines currently offer.
It doesn’t prevent you from loading and displaying 3D objects. In fact, an entire add-on product aptly named cocos3d has been created as an open source project to add 3D rendering support to cocos2d. Unfortunately, cocos3d is not compatible with cocos2d 2.0 at this point since cocos3d is still using OpenGL ES 1.1.
I have to say that the iOS devices are an ideal platform for great 2D games. The majority of new games released on the iTunes App Store are still 2D-only games even today, and even a lot of 3D games are essentially 2D games, gameplay-wise. 2D games are generally easier to develop, and the algorithms in 2D games are easier to understand and implement, making them ideal for beginners. In almost all cases, 2D games are less demanding on hardware, allowing you to create more vibrant and more detailed graphics.
It’s Got Physics
You can also choose from two physics engines that are already integrated with cocos2d. On the one hand there’s Chipmunk, and on the other there’s Box2D. Both physics engines superficially differ only in the language they’re written in: Chipmunk is written in C, and Box2D is written in C++. The feature set is almost the same in the two products. If you’re looking for differences, you’ll find some, but it requires a good understanding of how physics engines work to base your choice on the differences. In general, you should simply choose the physics engine you think is easier to understand and better documented. For most developers, that tends to be Box2D. On the other hand Chipmunk has a commercial Pro version which, among other things, gives you a native Objective-C interface to its API.
It’s Less Technical
What game developers enjoy most about cocos2d is how it hides the low-level OpenGL ES code. Most of the graphics are drawn using simple sprite classes that are created from image files. A sprite is a texture that can have scaling, rotation, and color applied to it by simply changing the appropriate Objective-C properties of the CCSprite class. You don’t have to be concerned about how this is implemented using OpenGL ES code, which is a good thing.
At the same time, cocos2d gives you the flexibility to add your own OpenGL ES code, including vertex and fragment shaders, at any time for any game object that needs it. Shaders are a way to program the graphics hardware and are beyond the scope of this book. If you’re thinking about adding some Cocoa Touch user interface elements, you’ll appreciate knowing that these can be miXEd in as well.
And cocos2d doesn’t just shield you from the OpenGL ES intricacies; it also provides high-level abstraction of commonly performed tasks, some of which would otherwise require extensive knowledge of the iOS SDK. But if you do need more low-level access or want to make use of iOS SDK features, cocos2d won’t hold you back.
It’s Still Programming
In general, you could say that cocos2d makes programming iOS games simpler while still requiring truly excellent programming skills first and foremost. Other iOS game engines such as Unity, Unreal, iTorque 2D, and Shiva focus their efforts on providing tool sets and workflows to reduce the amount of programming knowledge required. In return, you give away some technical freedom—and cash, too. With cocos2d, you have to put in a little extra effort, but you’re as close to the core of game programming as possible without having to actually deal with the core.
It’s Got a Great Community
The cocos2d community always has someone who will answer a question quickly, and developers are generally open to sharing knowledge and information. You can get in touch with the community on the official forum (www.cocos2d-iphone.org/forum) or on my own forum Cocos2D Central (http://cocos2d-central.com). Cocos2D Central is the best place to reach me personally.
New tutorials and sample source code are released on almost, and most of it’s for free. And scattered over the Internet you’ll find plenty of other resources to learn from and get inspired by.
Tip To stay up to date with what’s happening in the cocos2d community, I recommend following cocos2d on Twitter: http://twitter.com/cocos2d.
While you’re at it, you might want to follow me and Kobold2D as well: http://twitter.com/gaminghorror
Next, enter cocos2d in Twitter’s search box and then click the “Save this search” link. That way, you can regularly check for new posts about cocos2d with a single click. More often than not, you’ll come across useful cocos2d-related information that would otherwise have passed you by. And you’ll definitely get to know your fellow developers who are also working with cocos2d.
Once your game is complete and released on the App Store, you can even promote it on the cocos2d web site. At the very least, you’ll get the attention of fellow developers and ideally valuable feedback.
Why Use Kobold2D over cocos2d-iphone?
First of all, it’s a lot easier to get started with cocos2d-iphone development if you use Kobold2D from the start. You only need to run the Kobold2D installer to get everything you need: the source code, additional useful source code libraries, the template projects, the documentation, the tools, and more. You can start a new project right away.
You get 15 template projects instead of just 3, and all of them are ARC enabled. You’ll recognize that most of the template projects are variations of the projects you’ll create throughout the book. So you’ll feel right at home.
The most commonly used source code libraries are also integrated and ready to use. This includes the cocos2d-iphone-extensions project, the Lua scripting language, ObjectAL, iSimulate, SneakyInput, and more.
Kobold2D has additional convenience features that cocos2d-iphone doesn’t have. There’s helper code for Game Center, Ad Banners, Gesture Recognizers, PiXEl-Perfect Collision Detection, and simplified user input handling. KKInput gives you an easy-to-use, platform-independent wrapper to use Gesture Recognizers, the Gyroscope, Keyboard, and Mouse.
Additionally, most Kobold2D projects have targets for both iOS and Mac OS X. So if you plan on releasing your game to both App Stores, Kobold2D makes this dual-platform development a lot smoother and offers other enhancements under the hood, such as optimized Build Settings for each platform.
Then there’s KoboldScript. It’s a modern, powerful, yet simple Lua interface backed by Kobold2D to develop iOS and Mac OS X apps with. At the time of this writing it’s still a work in progress, so please visit www.koboldscript.com for the latest news and updates.
Finally, I use Kobold2D each and every day for my own work. I continue to tweak and improve it, and I make sure it stays up-to-date with the latest developments, be they new iOS devices, new Xcode versions, or simply new releases of cocos2d and the other libraries provided by Kobold2D. You’ll get a timely update and you’ll be able to upgrade your projects safely to a newer Kobold2D version with just one mouse click.
Other cocos2d Game Engines
You may have noticed that versions of cocos2d exist for a great variety of platforms, including Windows, JavaScript, and Android. There’s even a C++ version of cocos2d dubbed cocos2d-x that supports multiple mobile platforms all in one, including iOS and Android.
These cocos2d ports all share the same name and design philosophy but are written in different languages by different authors and are generally quite different from cocos2d for iOS. For example, the Android cocos2d port is written in Java, which is the native language when developing for Android devices.
If you’re interested in porting your games to other platforms, you should know that the various cocos2d game engines differ by a lot. Porting your cocos2d-iphone game to Android, for example, isn’t an easy task. First there’s the language barrier—all your Objective-C code must be rewritten in Java. When that’s done, you still need to make a lot of modifications to cope with numerous changes in the cocos2d API or possibly unsupported features of the port or the target platform. Finally, every port can have its own kind of bugs, and every platform has its own technical limitations and challenges.
Overall, porting iOS games written with cocos2d to other platforms that also have a cocos2d game engine entails almost the same effort as rewriting the game for the target platform using some other game engine. This means there’s no switch you can flip and it’ll work. The similarity of the cocos2d engines across various platforms is in name and philosophy only. If cross-platform development is your goal, you should take a look at cocos2d-x, which has most of the features of cocos2d-iphone, is backed financially by China Unicom, and continues to be updated and improved at an incredible pace.
In any case, I think you should still know about the most popular cocos2d game engines. Table 1–1 lists the cocos2d game engines that are frequently updated and are stable enough for production use. I didn’t include in this list cocos2d ports that are significantly out of date and haven’t been updated for months, if not years. That includes the defunct cocos2d for Windows project, whose only release dates back to May 2010, and the long obsolete ShinyCocos, a Ruby Wrapper based on cocos2d-iphone v0.8.2.
Table 1–1. Most Popular cocos2d Game Engine Ports
This Book Is for You
I’d like to imagine you picked this book because its title caught your interest. I suppose you want to make 2D games for iPhone, iPod touch, and iPad, and the game engine of your choice is cocos2d for iOS. Or maybe you don’t care so much about the game engine but you do want to make 2D games for iOS devices in general. Maybe you’re looking for some in-depth discussion on cocos2d, if you’ve been using it for a while already. Whatever your reasons for choosing this book, I’m sure you’ll get a lot out it.
As with every programming book, some prerequisites are nice to have and some are almost mandatory.
The only thing that’s mandatory for this book is some degree of programming experience, so let’s get that out of the way first. You should have an understanding of programming concepts such as loops, functions, classes, and so forth. If you have written a computer program before, preferably using an object-oriented programming language, you should be fine.
Still with me? Good.
So, you do have programming experience, but maybe you’ve never written anything in that obscure language called Objective-C.
You don’t need to know Objective-C for this book, but it definitely helps to know the language’s basics. If you’re already familiar with at least one other object-oriented programming language, such as C++, C#, or Java, you may be able to pick it up as you go. But to be honest, I found it hard to do that myself even after roughly 15 years of programming experience with C++, C#, and various scripting languages. There are always those small, bothersome questions about tiny things that you just don’t get right away, and they tend to steal your attention away. In that case, it’s handy to have a resource you can refer to whenever there’s something you need to understand about Objective-C.
Objective-C may seem scary with its square brackets, and you may have picked up some horror stories about its memory management and how there’s no garbage collection on iOS devices. Worry not.
First, Objective-C is just a different set of clothes. It looks unfamiliar, but the underlying programming concepts such as loops, classes, inheritance, and function calls still work in the same way as in other programming languages. The terminology might be different; for example, what Objective-C developers call sending messages is in essence the same as calling a method. As for memory management, with ARC you practically don’t have to concern yourself with memory management anymore. The very few exceptions are explained in the book, and for the most part they’re only telling the compiler that what you’re doing is intentional, and not an error, by adding a fancy-sounding keyword.
I learned from one invaluable Objective-C book, and I recommend it wholeheartedly as a companion book in case you want to learn more about Objective-C and Xcode: Learn Objective-C on the Mac by Mark Dalrymple and Scott Knaster, published by Apress.
There is also Apple’s “Introduction to the Objective-C Programming Language,” which proved valuable as an online reference. It’s available here: http://developer.apple.com/mac/library/DOCUMENTATION/Cocoa/Conceptual/ObjectiveC/Introduction/introObjectiveC.html.
What You Will Learn
I provide you with a fair share of my game-development experiences to show how interactive games are made. I believe that learning to program is not at all about memorizing API methods, yet a lot of game-development books I’ve read over the past two decades follow that “reference handbook” approach. But that’s what the API documentation is for. When I started programming some 20 years ago, I thought I’d never learn to program just by looking at a huge stack of compiler reference handbooks and manuals. Back at that time, compiler manuals were still printed, thick and heavy, and obviously didn’t come with fully searchable online versions. The World Wide Web was still in its infancy. All that information was stacked some 15 inches high on my desk, and it seemed very daunting to try to learn any of it, let alone all of it.
Today, I can’t recall most methods and APIs from memory, and I keep forgetting about those I used to know. I look them up time and time again. After 20 years of programming, I do know what’s really important to learn: the concepts, what works well and what doesn’t, where to look for info when I need to learn, and why it’s important to learn and follow best practices. Good programming concepts and best practices stick around for a long time, and they help with programming in any language. Learning concepts is done best by understanding the rationale behind the choices that were made in designing, structuring, and writing the source code. That’s what I focus on the most.
What Beginning iOS Game Developers Will Learn
I also ease you into the most important aspects of cocos2d and Kobold2D. I focus on the kind of classes, methods, and concepts you should be able to recall from memory just because they are so fundamental to programming with cocos2d.
You’ll also learn about the essential tools supporting or being supported by cocos2d. Without these tools, you’d be only half the cocos2d programmer you can be. You’ll use tools like TexturePacker and ParticleDesignerto create games that are increasingly complex and challenging to develop. Because of the scope of this book, these games aren’t complete and polished games, nor can I discuss every line of code. Instead I annotate the code with many helpful comments so that it’s easy to follow and understand.
I leave it up to you to improve on these skeleton game projects, and I’m excited to see your results. I think giving you multiple starting points to base your own work on works better than walking you through the typical Asteroids games over the course of the whole book.
I chose the game projects for this book based on popularity on the App Store and relevance for game developers, who often inquire about how to solve the specific problems that these games present. For example, the line-drawing game genre is a huge favorite among cocos2d game developers, yet line-drawing games require you to overcome deceivingly complex challenges.
I’ve also seen a fair bit of other developers’ cocos2d code and followed the discussions on code design, structure, and style. I base my code samples on a framework that relies on composition over inheritance and explain why this is preferable. One other frequent question that has to do with code design is how different objects should communicate with each other. There are interesting pros and cons for each approach to code design and structure, and I want to convey these concepts because they help you write more stable code with fewer bugs and better performance.
What iOS App Developers Will Learn
So, you’re an iOS app developer, and you’ve worked with the iOS SDK before? Perfect. Then you’ll be most interested in how making games work in a world without Interface Builder. In fact, you’ll be using other tools. They may not be as shiny as Apple’s tools, but they’re useful nonetheless.
The programming considerations will change, too. You don’t normally send and receive a lot of events in game programming, and you let a larger number of objects decide what to do with an event. For performance reasons and to reduce user input latency, game engine systems often work more closely connected with each other. A lot of work is done in loops and update methods, which are called at every frame or at specific points in time. Whereas a user interface-driven application spends most of its time waiting for a user’s input, a game keeps pushing a lot of data and piXEls behind the scenes, even when the player is not doing anything. So there’s a lot more going on, and game code tends to be more streamlined and efficient because of concerns for performance.
What Cocos2d Developers Will Learn
You’re already familiar with cocos2d? You may be wondering whether you can learn anything new from this book. I say you will. Maybe you want to skip the first chapters, but you’ll definitely get hooked by the games’ sample source code supplied with the book. You’ll learn how I structure my code and the rationale behind it. You’ll probably find inspiration reading about the various games and how I implemented them. You’ll also benefit from a good number of tips and you’ll learn how Kobold2D helps you develop games faster.
Most importantly, this book isn’t written by some geek you’ve never heard of and never will hear from again, with no e-mail address or web site to post your follow-up questions. Instead, it’s written by a geek you may not have heard of but who will definitely be around. I’m actively engaged with the cocos2d community at the book’s companion blog www.learn-cocos2d.com, where I’ll continue to improve this book as well as improving how we write App Store games with Kobold2D and KoboldScript.
What’s in This Book
Here’s a brief overview of the chapters in this book. The second edition added two entirely new chapters: Chapter 15 discusses integration of UIKit views with cocos2d, and Chapter 16 introduces Kobold2D, my own take on a cocos2d development environment with additional convenience features. The third edition sees all chapters updated to Cocos2D v2.0 and made compatible with Kobold2D v2.0, and all source code is using ARC.
I cover setting up cocos2d for development, installing project templates, and creating the first “Hello World” project. You’ll learn about cocos2d basics, such as scenes and nodes.
I explain the essential cocos2d classes that you’ll need most often, such as sprites, transitions, and actions. And you’ll learn how to use them, of course.
Enemies drop from the top, and you have to avoid them by tilting your device. This will be our first simple game using accelerometer controls.
Chapter 5, “Game Building Blocks”
Now prepare yourself for a bigger game, one that requires a better code structure. You’ll learn how scenes and nodes are layered and the various ways that game objects can exchange information.
You’ll learn what a texture atlas is and why you’ll be using it for the next game and how to create a texture atlas with the TexturePacker tool.
Chapter 7, “Scrolling with Joy”
With the texture atlas ready, you’ll learn how to implement a parallax scrolling shooter game, controlled by touch input.
Without enemies, our shooter wouldn’t have much to shoot at, right? I show you how to add game-play code to spawn, move, hit, and animate the enemy hordes.
Chapter 10, “Working with Tilemaps”
Infinitely jumping upward, you’ll apply what you’ve learned from the side-scrolling game in portrait mode to create another popular iOS game genre.
Chapter 11, “Isometric Tilemaps
Because cocos2d supports the TMX file format, you’ll take a look at how to create tile-based games using the Tiled editor.
This is a primer on using the Chipmunk and Box2D physics engines—and the crazy things you can do with them.
In this chapter you’ll create a basic pinball table using the Box2D physics engine. The collision shapes are created with the help of the PhysicsEditor tool.
Learn how to turn the isometric tilemap game from Chapter 11 into a multiplayer game for two, complete with leaderboards and achievements.
Chapter 15, “Cocos2d and UIKit Views”
This chapter goes into depth on how to mix and match cocos2d with regular Cocoa Touch, particularly UIKit views. You’ll learn how to add UIKit views to a cocos2d game but also the reverse: how to integrate cocos2d in an existing UIKit app.
Chapter 16, “Kobold2D Introduction”
Kobold2D is my take on improving the cocos2d game engine by making it easier to work with while adding features such as ARC compatibility and Lua scripting to it. In this chapter you’ll learn how to set up new Kobold2D projects and what’s special about Kobold2D.
This is where the book ends and your journey continues. You’ll get lots of inspiration on where to go from here and food for thought.
Where to Get the Book’s Source Code
One of the most frequently asked questions following the release of the first edition of this book was about where to get the book’s source code. I’ve added this little section to answer this question.
You can get the book’s source code on the book’s page at www.apress.com. The source code is available on the Source Code/Downloads tab.
Alternatively, you can download the source code from the Downloads section on Learn Cocos2D: www.learn-cocos2d.com/store/book-learn-cocos2d.
Of course, you can always type the code directly from the book if you prefer. But it may come in handy to have the code ready, in case you need to compare what you typed with what the code is supposed to look like. I also continue to upgrade the downloadable source code on Learn Cocos2D to fix issues with newer Xcode or iOS versions.
Most importantly the source code download contains the exact versions of cocos2d and Kobold2D used by the source code in this book. Because both projects continue to be improved, there’s a possibility that the latest download from the web site may not be 100% compatible with the book’s descriptions and source code. Therefore I recommend you install and use the versions distributed with the source code while you’re reading the book.
Questions and Feedback
I do hope I get the right mixture of easing you into cocos2d and iOS game development while challenging you with advanced game-programming concepts.
If at any time I fail and leave you wondering, please feel free to ask your questions on Cocos2D Central (www.cocos2d-central.com). I’ll also continue to post frequently about cocos2d news and developments on the Learn Cocos2D companion web site for this book at www.learn-cocos2d.com. Your feedback is always welcome!