Beginning iOS 5 Games Development: Using the iOS SDK for iPad, iPhone and iPod touch (Beginning Apress)

342 Pages·2011·54.29 MB·English

by  Lucas Jordan

For your convenience Apress has placed some of the front
matter material after the index. Please use the Bookmarks
and Contents at a Glance links to access them.
Contents at a Glance
Contents .............................................................................................................. v
About the Author ................................................................................................ ix
About the Technical Reviewer ............................................................................ x
Acknowledgments ............................................................................................. xi
Introduction ...................................................................................................... xii
■Chapter 1: A Simple First Game ....................................................................... 1(cid:1)
■Chapter 2: Setting Up Your Game Project ...................................................... 11(cid:1)
■Chapter 3: Explore the Game Application Life Cycle ..................................... 37(cid:1)
■Chapter 4: Quickly Build an Input-Driven Game ............................................ 65(cid:1)
■Chapter 5: Quickly Build a Frame-by-Frame Game ....................................... 95(cid:1)
■Chapter 6: Create Your Characters: Game Engine,
Image Actors, and Behaviors .................................................... 127(cid:1)
■Chapter 7: Build Your Game: Vector Actors and Particles ........................... 155(cid:1)
■Chapter 8: Building Your Game: Understanding Gestures and Movements . 181(cid:1)
■Chapter 9: Game Center and Social Media .................................................. 215(cid:1)
■Chapter 10: Monetizing via the Apple App Store ......................................... 237(cid:1)
■Chapter 11: A Completed View Belt Commander ........................................ 253(cid:1)
■Appendix A: Designing and Creating Graphics ............................................ 287(cid:1)
Index ............................................................................................................... 305
iv
Introduction
This book is an introduction to game development for Apple’s iOS devices. I hope you are reading
this because you are excited about developing a cool new game for the iPhone or iPad. It is the
goal of this book to educate the reader on the many facets of building a game. The topics range
from the mundane tasks of organizing your start screen to the subtle math required to get an
animation just right.
By the end of this book, you will be familiar with not just the details of animating images, but
also the many other details that go into a game that should be considered before development
even starts. For example, if you know you want to include Game Center in your application, it
makes sense to understand Game Center and how that affects your design.
The book walks you through many examples, each building on the other to create a complete
picture of what an iOS game looks like. To facilitate this, I have written a complete (though
simple) game that will serve as context in the examples, as well as give you a complete game to
use as a roadmap in your own game development. The game is called Belt Commander and is
shown in Figure 1.
In Figure 1, we see the game Belt Commander’s start screen and a shot of the game in action.
This game includes elements from every chapter in this book, and I hope it is a useful tool.
This game does not have the polish required for me to put it in the App Store, but it will serve
as a starting point for a version of the game I do intend to publish. I just want to point this out,
because I hope it highlights the practical approach of this book. The lessons I learned building
Belt Commander have been captured in these pages. You can find the published game at
claywaregames.com.
If you have questions about the code in this book, or about iOS development in general,
please feel free to contact me directly at [email protected].
xii
■ INTRODUCTION

Figure 1. Belt Commander
Chapter-by-Chapter Overview
Each chapter in this book covers a particular topic pertinent to game development. The source
code in each chapter is taken from a working sample project. Some chapters have their own
projects, while others share a single, bigger project.
Chapter 1
Chapter 1 provides a walkthrough of setting up a simple project using Xcode. Using the code
provided with this book, you will make your first simple game.
xiii
■ INTRODUCTION

Chapter 2
Chapter 2 continues our exploration of Xcode and the game project. In this chapter, we talk about
UIViewControllers and how they are designed to encapsulate functionality into reusable
components. We will also address the issue of the different devices and orientations and
applications you must work with, as shown in Figure 2.

Figure 2. A simple game in portrait view on the iPhone and landscape view on the iPad
In Figure 2, we see a simple Rock, Paper, Scissors game being run on both the iPad and the
iPhone. On the iPhone, the application is running in portrait view, while on the iPad the game is
running in landscape view. Not every game needs to support all devices and orientations, but
some do. In this chapter, you will learn how to get a project off on the right foot, so you don’t have
to fight with it down the road.
Chapter 3
Chapter 3 is concerned with understanding the life cycle of an iOS application. It will cover how
an application is initialized, how to navigate between a number of different views, and how to
handle the application going into the background. Figure 3 shows the different views in the
project we will be working with.
xiv
■ INTRODUCTION

Figure 3. The four views of the game Coin Sorter
In Figure 3, we see the four views of the game Coin Sorter. You will learn in this chapter how
to design the navigation between these views, how to persist game state and high scores, and you
will look at the details of preserving state when an applications enter the background. This will
give you the context in which you can create games.
Chapter 4
In Chapter 4, we dive into the details of creating the fun part of the game. Up until this point,
we have been mostly concerned with the stuff that surrounds the game itself. In this chapter, we
will look at the implementation of the Cion Sorter game. You will learn how to build a game that
is driven by user input. Figure 4 shows a preview of the type of things you will be learning.
xv
■ INTRODUCTION

Figure 4. A preview of how UIViews work
In Figure 4, we see a visual description of the location of a view is described in iOS. Up until
Chapter 4, we have glossed over the exact details of how views are positioned in the screen. In
Chapter 4, we take our first in-depth look at the class UIView and how to use Core Graphics to
describe the location of UIView. The techniques you learn will serve you in building the input-
driven game and come into play in the following chapters, when we do considerable work with
UIView and UIImageView.
Chapter 5
The game built in Chapter 4 uses an architecture suitable for “casual” games. Chapter 5
introduces the idea of a frame-by-frame game, where our code is responsible for drawing every
frame of an animation. Figure 5 shows an overview of the architecture we will be creating and the
sample animation that results.

Figure 5. Architecture of frame-by-frame game with sample game
xvi
■ INTRODUCTION

In Figure 5, we see on the left a flow chart describing how a frame-by-frame game works. We
will work through each step to illustrate how to create a sample game like the one you see on the
right. You will also be introduced to the space theme that will dominate the rest of the book,
because in this chapter you learn the core principles for building our example game, Belt
Commander.
Once we have a basic idea of how a frame-by-frame game works, we move on to the next
chapter, where we start creating classes that provide the core functionality required to make a
game.
Chapter 6
In Chapter 6, we take the core principles from Chapter 5 and wrap up that functionality into some
reusable classes. In effect, we start building a basic game engine. We create a master class for
managing the game and introduce the concepts of actors and behaviors. Figure 6 shows an
example of an actor.

Figure 6. A Sample actor: The power-up
In Figure 6, we see the images that make up the actor power-up. An actor is an object in a
game that encapsulates its behavior and visual representation. By the end of this chapter, you will
have a simple pattern for creating a game, adding actors to it, and watching the actors animate
onscreen in accordance with their behavior. In this chapter, we identify the core elements of
building this style of game.
Chapter 7
Chapter 7 takes the framework from Chapter 6 and adds a few additional features such as actors
drawn with vectors and particles. In the process of learning about how to create these new types
of actors, we build a couple of compelling examples, one of which is shown in Figure 7.
xvii
■ INTRODUCTION

Figure 7. An example of actors composed of a particle system
In Figure 7, we see three comets flying across the screen. Each comet is composed of many
small actors called particles. Particles are used to create compelling visual effects that would be
hard to capture with a single image or animation.
By the end of this chapter, we will have several examples of setting up a game and creating
custom actors to populate it with.
Chapter 8
Having established how to create a scene populated with custom actors in the previous two
chapters, we are ready to look at user interactions. Up until this point, the examples have pretty
much just run on their own, or with very limited user actions. In this chapter, we will explore all
of the user input options, as shown in Figure 8.
xviii