Beginning iPhone Games Development

Title Page

Copyright Page

Contents at a Glance

Table of Contents

About the Authors

About the Technical Reviewer

Acknowledgments

Introduction

Chapter 1 A Revolutionary Gaming Platform: Games for Everyone, Anytime, Anywhere

The Ever-Present iPhone

Mass Appeal—There’s a Gamer Born Every Minute

User Interfaces—Death of the D-Pad

Connectivity—Plays Well with Others

User Data—This Time It’s Personal

Device Performance—A Multimedia Powerhouse

Dev Kit? You’re Holding It!

Innovation—Good Things Come from Small Developers

Summary

Chapter 2 Developing iPhone Games: Peeking Inside the iPhone Toolbox

Development Tools and Environment

UIKit

Quartz 2D and Core Animation

OpenGL ES

Audio APIs

Networking

Summary

Chapter 3 Moving Images on a Small Screen—UIKit Controls

A Quick Introduction to Cocoa Touch

The Objective-C Language

A Brief Objective-C Example

Using an Objective-C Class

Memory Management in Objective-C

Cocoa Touch and the UIKit Framework

Introducing UIView

The Frame Property

The Background Color and Alpha Properties

The Center Property

Building a Simple Game

Creating an Xcode Project

Creating the IVBricker User Interface

Examining the Main Window File

Examining the View Controller File

Setting View Properties

Adding Components to the View

Adding Code to the View Controller

Connecting a Property with a Component

Snazzy Graphics Make the Grade

Adding the Image

The Illusion of Motion

Rocking and Grooving with User Input

Handling Accelerometer Input

Handling Touchscreen Input

When Objects Collide

Failure Conditions

Winning Conditions

Loading and Displaying Images Programmatically

Creating the Grid of Bricks

Detecting image View Collisions

Changing the Timer to CADisplayLink

The End?

Application Delegate Events

Application Termination

Application Interruptions

Low Memory Warnings

Saving and Loading Game State

Managing Memory with a Custom Image Loader

Animating Images

Using the UIImageView Animation Properties

Using NSTimer for Animation

Using CADisplayLink for Animation

Summary

Chapter 4 She Shoots, She Hits, She Scores!

Quartz 2D Game Overview

Every Artist Needs a Canvas

Your First Graphic with Quartz 2D

Saving and Restoring the Context

Adding Color

Sprites

Creating the Sprite Class

Using the Sprite Class

Which Way Is Up?

Changing to Landscape Orientation

Centering the Origin

Vector Art

Creating the VectorSprite Class

Using the VectorSprite Class

Flipbook Animations

Creating the AtlasSprite Class

Modifying the Sprite Class

Using the AtlasSprite Class

Heads-Up Displays

Creating the TextSprite Class

Using the TextSprite Class

Asteroids Game Architecture

The Asteroids Game Loop

The Asteroids Model

The Asteroids View

The Asteroids Game Controller

Conclusion

Chapter 5 Flipping Out and Sweeping Away with Core Animation

Core Animation Sample Project Overview

Animating UIViews

Simple Movement

Animation Curves

Reverse and Repeat

Delay, Ease-In, and Ease-Out

UIView Transforms

UIView Transitions

Animating Core Animation Layers

Implicit Animations

Timing Functions

Layer Animation Transitions

Fade

Move In, Push, and Reveal

Summary

Chapter 6 OpenGL Basics: Wrapping Your Head Around the OpenGL API

What Is OpenGL ES and Why Do I Care?

Understanding the 3D World

Matrix Basics: Taking the Red Pill

Bringing It All Together

Matrix Types

The Model and the Model Matrix

The View Matrix

The Projection

The Viewport

Stateful API

Rendering Basics

The Basic Game Template

Wrapping the CAEAGLLayer in a View: EAGLView

First Steps: The Init Method

Frame Buffers, Render Buffers, and Depth Buffers

Seeing into the OpenGL World

Drawing and Rendering

How to Draw Stuff with OpenGL

The Scene and Mesh Objects

Pushing and Popping Matrixes

Putting Your Objects in the Scene

Moving Objects

Scaling Objects

Spinning Objects

Defining Your Object in 3D Space

Vertex and Color Information

Understanding Triangles

The Game Loop and the Timer

The Input Controller

The App Delegate

Summary

Chapter 7 Putting It Together: Making a Game in OpenGL

Space Rocks! Game Design

Getting Started with the Template

Rotation Makes the World Go 'Round

3D Point Upgrade

Adding Buttons

Creating a Button Object

Working with Vertex Data

Storing Buttons

Detecting Touches

Wiring Up the Buttons

Building a Better Spaceship

Going Mobile

Adding the Spaceship

Adding and Removing Scene Objects

Falling Off the Edge of the Screen

Space Rocks!

Adding Missiles

Firing Missiles

Removing Unwanted Missiles

Making Nicer Buttons

Collision Detection

What Is a Collision?

Collision-Detection Techniques

Optimized Collision Detection

Radius-to-Radius Collision Check

Collisions on the Rocks

Centroid and Radius

Colliders and Collidees

Take the Red Pill: The Transform Matrix

The Collider Object

The Collision Controller Object

Back to the Scene Controller

Scene Object Updates

Collision Checking Redux

Summary

Chapter 8 The Next Steps: Atlases, Sprites, and Particles—Oh My!

Textures and Texture Atlases

What Is a Texture Anyway, and Why Do I Care?

Getting Image Data into OpenGL

Binding Textures

UV Is Not Bad for Your Skin

You Get a Textured Quad!

Say Hello to the Texture Atlas

Switching the Old and Busted for the New Hotness

A Nicer User Interface

Colors with Textures

Sprite Animation

Frame Rate Independence

Animations for Everything

From 2D to 3D

It’s Only One More D—What’s the Big Deal?

Where Do 3D Models Come From?

From Modeler to Screen

What Is Normal?

Standardizing on GL_TRIANGLES

Textures Plus Models

Shadows Define Shape

Depth Buffer and Face Culling

Collision Detection Tweaks

Particle Systems Add Life to Your Game

What Is a Particle System?

A Lot of Random Numbers

The Nitty-Gritty of a Particle System: Particles

Particle Emitters and You

Tuning Our System

Particle Systems for Everything

What the Future Holds: Shaders

Summary

Chapter 9 Introduction to Core Audio

Audio Services Provided by Core Audio

Audio Units

Audio File Services

Audio File Stream Services

Audio Conversion Services

Extended Audio File Services

Audio Session Services

System Sound Services

Audio Queue Services

AVFoundation

OpenAL

The Core Audio Frameworks

Codecs and File Formats

Codecs Supported by Core Audio

File Formats Supported by Core Audio

Using afconvert to Convert Between Formats

Hardware-Accelerated Codecs: Restricted and Unrestricted Codec Groups

Codec and File Format Suggestions

Alerts and Vibration: Introducing System Sound Services

The Case Against System Sound Services for General Sound Effects

A System Sound Services Example

A Comment on Asynchronous Playback

Setting Policies for Your Audio: Introducing Audio Session Services

Boilerplate Code and Procedures for Using Audio Session Services

Detecting Hardware and Getting Properties

Easy Audio Playback in Objective-C with AVFoundation

Mission Complete…but Our Princess Is in Another Castle!

Chapter 10 Making Noise with OpenAL

OpenAL Overview

What OpenAL Supports

Some History of OpenAL

My Story and Goals for Audio Coverage

Roadmap for the Audio Coverage

Setting Up Basic Sound in OpenAL

Setting Up an Audio Session

Opening a Device

Advanced OpenAL Tip: Specifying OpenAL Devices

Creating a Context

Advanced Tip: Using Attribute Lists

Activating the Context

Generating Sound Sources

Generating Data Buffers

Loading Sound Data from Files

Submitting Sound Data to OpenAL Data Buffers

Advanced OpenAL Tip: The alBufferDataStatic Extension

Attaching a Data Buffer to a Sound Source

Playing Sound

Shutting Down and Cleaning Up

Cow Launched!

Exposing Flaws and the Missing Details

Adding More Sounds

Problems to Notice

OpenAL Error Checking

Audio Session Interruptions

OpenAL Extensions for iPhone OS

Performance Notes

OpenAL Source Limits: “It’s a Secret to Everybody”

Sound Resource Manager: Fixing the Design

Overview of the Resource Manager

Initial Cleanup

The Sound File Database (Cache System)

OpenAL Source Management (Reserving and Recycling)

Integration with Space Rocks!

SoundDidFinishPlaying Callbacks

Final Integration Steps for Space Rocks!

Handling When All Available Sources Are Exhausted

Final Demo Embellishments

Save Point Reached

Chapter 11 3D Audio—Turning Noise into Game Sounds

The Design of OpenAL: Sources, Buffers, and Listeners

Limits of 3D Audio in OpenAL

Integrating the Listener into Space Rocks!

Creating the Listener Class

Picking the Designated Driver

Adding Positions to Sounds

Handling Initial Positioning on Creation

Disabling Distance Attenuation

Working Around an alDistanceModelBug: Disabling Attenuation on a Per-Source Basis

Listener Orientation

Right-Handed Coordinate Systems and the Right-Hand Rule

Unit Circle, Polar-to-Rectangular Coordinates, Phase Shifting, and Trigonometric Identities

Integration into Space Rocks!

Source Direction and Cones

Inner Cone, Outer Cone, and Transitional Zone

Implementation Time

Velocity and the Doppler Effect

Velocities and Scaling Factors

Doppler Effect Example Time

Distance Attenuation

Attenuation Models

Inverse Distance

Inverse Distance Clamped

Linear Distance

Linear Distance Clamped

Exponential Distance

Exponential Distance Clamped

Distance Attenuation Parameters

Picking a Distance Model

Back to Space Rocks!

Using Relative Sound Properties to Selectively Disable 3D Effects

Achievement Unlocked: Use All OpenAL 3D Features

Chapter 12 Streaming: Thumping, Pulse-Quickening Game Excitement

Music and Beyond

iPod Music Library (Media Player Framework)

Playing iPod Music in Space Rocks!

Adding a Media Item Picker

Shake It! (Easy Accelerometer Shake Detection)

Audio Streaming

AVFoundation-Based Background Music for Space Rocks!

The Playback Sound Controller

Integration into Space Rocks!

OpenAL Buffer Queuing Introduction

Initialization

Unqueuing

Queuing

Buffer Underrun

Pausing

Fast Forwarding and Rewinding

Startup Number of Buffers and Filling the Queue

How to Choose the Number and Size of Buffers

OpenAL-Based Background Music for Space Rocks!

A New Buffer Data Class for Streaming

Unqueue the Processed Buffers

Queue a New Buffer If Necessary

Handle a Buffer Underrun

Handle EOF and Finished Playing

OpenALSoundController Changes

BBSceneController Integration

Analysis: Number of Buffers and Buffer Sizes

Star Power Ready!

OpenAL Speech for Space Rocks!

EWSoundSourceObject: Finishing the implementation

BBSceneController: Adding a New UFO

UFO: Taunting and Callbacks

The alBufferDataStatic Crashing Bug

Work-Arounds

Audio Queue Services Based Background Music for Space Rocks!

Rewind and Looping

Audio Session Interruptions

Perfect Full Combo!

Audio Capture

Audio Capture APIs

AVFoundation: File Recording with AVAudioRecorder

OpenAL: Capture Oscilloscope

The Capture APIs

ALC Device Enumeration

Capturing Audio

Back to OpenGL

Vertex Buffer Objects

Some Notes on OpenGL and OpenAL Optimization

The End of the Audio Road

Chapter 13 Networking for iPhone Games: Introduction

Meet the Network

Network Interfaces

TCP/IP

Bonjour

iPhone SDK and Networking

Sockets and Connections

BSD Socket API

CFNetwork

NSNetServices

GameKit

Summary

Chapter 14 Going Head to Head

Hello Pong!

Using Peer Picker to Find a Human Opponent

What Does It Look Like?

How Does It Work?

Making the Connection

Sending and Receiving Messages

Rolling the Dice

Ready…Set…Go!

Hits and Misses

The Paddle Comes Alive

Game Over: Handling Disconnects

Summary

Chapter 15 Party Time

8 x 3 = ?

Starting Point

Where Are We Going?

What’s in the Structure?

Making Connections

Introducing the Connection and Stream Objects

Connection Initialization

Closing and Cleanup

Reading Data

Writing Data

Handling Stream Events

The Complete Picture

Socket Servers

The SocketServer Class

Socket Server Initialization

Publishing via Bonjour

Starting and Stopping

Finding Servers via Bonjour

Looking for Servers

Connecting to Servers

Final Details

Implementing the Game Client

Tracing the Logic

Choosing the Network Message Format

Making It Talk

Hooking It Up

Implementing the Game Server

Managing Players

Laying It Out

Initialization

Players Joining and Leaving

Starting and Stopping Game Rounds

Collecting and Processing Answers

Hooking It Up

Summary

Chapter 16 Connecting with the Outside World

Challenges

Au Revoir, Bonjour!

No GameKit Peer-to-Peer for You!

Server, interrupted

Lag

It’s All Greek to Me…

And a Bunch More

Basics of Online Game Play

Client/Server Games

Connecting to a Game Server Without Bonjour

Peer-to-Peer Games

Something About Reinventing the Wheel

Like a Drop in the Ocean

Making Games More Social

Sharing High Scores Online

Chasing Ghosts

Chatting

Summary

Chapter 17 Putting It All Together: Now Comes the Fun Part

What We’ve Covered

Some Game Design Tips

Wrapping It Up

Index