Praise for Introduction to Game Design, Prototyping, and

Development

“Introduction to Game Design, Prototyping, and Development combines a solid grounding in

evolving game design theory with a wealth of detailed examples of prototypes for digital
games. Together these provide an excellent introduction to game design and development
that culminates in making working games with Unity. This book will be useful for both intro-
ductory courses and as a reference for expert designers. I will be using this book in my game
design classes, and it will be among those few to which I often refer.”
—Michael Sellers
Professor of Practice in Game Design, Indiana University, former Creative Director
at Rumble Entertainment, and General Manager at Kabam

“Prototyping and play-testing are often the most misunderstood and/or underutilized steps
in the game design and development process. Iterative cycles of testing and refining are
key to the early stages of making a good game. Novices will often believe that they need to
know everything about a language or build every asset of the game before they can really get
started. Gibson’s new book prepares readers to go ahead and dive in to the actual design and
prototyping process right away; providing the basics of process and technology with excellent
“starter kits” for different types of games to jumpstart their entry into the practice.”
—Stephen Jacobs
Associate Director, RIT Center for Media, Art, Games, Interaction and Creativity (MAGIC)
and Professor, School of Interactive Games and Media

“Jeremy Gibson’s Introduction to Game Design, Prototyping, and Development deftly combines
the necessary philosophical and practical concepts for anyone looking to become a Game
Designer. This book will take you on a journey from high-level design theories, through game
development concepts and programming foundations in order to make your own playable
video games. Jeremy uses his years of experience as a professor to teach the reader how to
think with vital game design mindsets so that you can create a game with all the right tools
at hand. A must-read for someone who wants to dive right into making their first game and a
great refresher for industry veterans.”
—Michelle Pun
Senior Game Designer, Zynga
This page intentionally left blank
Introduction to Game
Design, Prototyping,
and Development
 The Addison-Wesley
Game Design and Development Series

Visit informit.com/series/gamedesign for a complete list of available publications.

Essential References for Game Designers and Developers

T hese practical guides, written by distinguished professors and industry gurus,

cover basic tenets of game design and development using a straightforward,
common-sense approach. The books encourage readers to try things on their own
and think for themselves, making it easier for anyone to learn how to design and
develop digital games for both computers and mobile devices.

 
Make sure to connect with us!
informit .com/socialconnect
 Introduction to Game
Design, Prototyping,
and Development
From Concept to Playable
Game—with Unity® and C#

Jeremy Gibson

Upper Saddle River, NJ • Boston • Indianapolis • San Francisco

New York • Toronto • Montreal • London • Munich • Paris • Madrid
Capetown • Sydney • Tokyo • Singapore • Mexico City
Many of the designations used by manufacturers and sellers to distinguish their Editor-in-Chief
products are claimed as trademarks. Where those designations appear in this book, and Mark Taub
the publisher was aware of a trademark claim, the designations have been printed with
initial capital letters or in all capitals. Senior Acquisitions
Editor
The authors and publisher have taken care in the preparation of this book, but make Laura Lewin
no expressed or implied warranty of any kind and assume no responsibility for errors
or omissions. No liability is assumed for incidental or consequential damages in Senior Development
connection with or arising out of the use of the information or programs contained Editor
herein. Chris Zahn
For information about buying this title in bulk quantities, or for special sales Managing Editor
opportunities (which may include electronic versions; custom cover designs; and Kristy Hart
content particular to your business, training goals, marketing focus, or branding
interests), please contact our corporate sales department at [email protected] Project Editor
or (800) 382-3419. Elaine Wiley

For government sales inquiries, please contact [email protected]. Copy Editor

Keith Cline
For questions about sales outside the U.S., please contact international@pearsoned.
com. Indexer
Visit us on the Web: informit.com/aw Ken Johnson

Library of Congress Control Number: 2014936195 Proofreader

Paula Lowell
Copyright © 2015 Pearson Education, Inc.
All rights reserved. Printed in the United States of America. This publication is protected Technical Editors
by copyright, and permission must be obtained from the publisher prior to any Marc Destefano
prohibited reproduction, storage in a retrieval system, or transmission in any form or Charles Duba
by any means, electronic, mechanical, photocopying, recording, or likewise. To obtain Margaret Moser
permission to use material from this work, please submit a written request to Pearson Publishing Coordinator
Education, Inc., Permissions Department, One Lake Street, Upper Saddle River, New Olivia Basegio
Jersey 07458, or you may fax your request to (201) 236-3290.
Cover Designer
ISBN-13: 978-0-321-93316-4
Chuti Prasersith
ISBN-10: 0-321-93316-8
Text printed in the United States on recycled paper at RR Donnelley in Book Designer
Crawfordsville, IN. Bumpy Design

First printing, July 2014 Compositor

Nonie Ratcliff
 This book is dedicated to:
My wife Melanie, the love of my life,
for her love, intellect, and support
My parents and sisters
And my many professors, colleagues, and students
who inspired me to write this book.
This page intentionally left blank
Contents at a Glance
Part I Game Design and Paper Prototyping . . . . . . . . . . . . . . . . 1
1 Thinking Like a Designer . . . . . . . . . . . . . . . . . . . . . . . . 3
2 Game Analysis Frameworks . . . . . . . . . . . . . . . . . . . . . . 19
3 The Layered Tetrad . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4 The Inscribed Layer . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5 The Dynamic Layer . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
6 The Cultural Layer . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
7 Acting Like a Designer . . . . . . . . . . . . . . . . . . . . . . . . . 89
8 Design Goals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
9 Paper Prototyping . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
10 Game Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
11 Math and Game Balance . . . . . . . . . . . . . . . . . . . . . . . 155
12 Puzzle Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
13 Guiding the Player . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
14 The Digital Game Industry . . . . . . . . . . . . . . . . . . . . . . 211

Part II Digital Prototyping . . . . . . . . . . . . . . . . . . . . . . . . . . 223

15 Thinking in Digital Systems . . . . . . . . . . . . . . . . . . . . . 225
16 Introducing Our Development Environment: Unity . . . . . . 235
17 Introducing Our Language: C# . . . . . . . . . . . . . . . . . . . 253
18 Hello World: Your First Program . . . . . . . . . . . . . . . . . . 263
19 Variables and Components . . . . . . . . . . . . . . . . . . . . . 281
20 Boolean Operations and Conditionals . . . . . . . . . . . . . . 299
21 Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
22 Lists and Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
23 Functions and Parameters . . . . . . . . . . . . . . . . . . . . . . 349
24 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
25 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
26 Object-Oriented Thinking . . . . . . . . . . . . . . . . . . . . . . 391
27 The Agile Mentality . . . . . . . . . . . . . . . . . . . . . . . . . . 405
x CONTENTS AT A GLANCE

Part III Game Prototype Examples and Tutorials. . . . . . . . . . . . . 417

28 Prototype 1: Apple Picker . . . . . . . . . . . . . . . . . . . . . . 419
29 Prototype 2: Mission Demolition . . . . . . . . . . . . . . . . . . 449
30 Prototype 3: Space SHMUP . . . . . . . . . . . . . . . . . . . . . 487
31 Prototype 4: Prospector Solitaire. . . . . . . . . . . . . . . . . . 561
32 Prototype 5: Bartok . . . . . . . . . . . . . . . . . . . . . . . . . . 621
33 Prototype 6: Word Game . . . . . . . . . . . . . . . . . . . . . . . 657
34 Prototype 7: QuickSnap . . . . . . . . . . . . . . . . . . . . . . . 695
35 Prototype 8: Omega Mage . . . . . . . . . . . . . . . . . . . . . 727

Part IV Appendices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 791

A Standard Project Setup Procedure. . . . . . . . . . . . . . . . . 793
B Useful Concepts Reference . . . . . . . . . . . . . . . . . . . . . 799
C Online References . . . . . . . . . . . . . . . . . . . . . . . . . . . 851

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 857
Contents
Preface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxiv

Part I Game Design and Paper Prototyping . . . . . . . . . . . . . . 1

1 Thinking Like a Designer . . . . . . . . . . . . . . . . . . . . . . 3

You Are a Game Designer. . . . . . . . . . . . . . . . . . . . . . . . . . 4
Bartok: A Game Exercise. . . . . . . . . . . . . . . . . . . . . . . . . . . 4
The Definition of Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2 Game Analysis Frameworks . . . . . . . . . . . . . . . . . . . 19

Common Frameworks for Ludology . . . . . . . . . . . . . . . . . . 20
MDA: Mechanics, Dynamics, and Aesthetics . . . . . . . . . . . . . 20
Formal, Dramatic, and Dynamic Elements . . . . . . . . . . . . . . 24
The Elemental Tetrad . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

3 The Layered Tetrad . . . . . . . . . . . . . . . . . . . . . . . . . 31

The Inscribed Layer . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
The Dynamic Layer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
The Cultural Layer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
The Responsibility of the Designer . . . . . . . . . . . . . . . . . . . 36
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

4 The Inscribed Layer. . . . . . . . . . . . . . . . . . . . . . . . . 39

Inscribed Mechanics . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Inscribed Aesthetics . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Inscribed Narrative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Inscribed Technology . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
xii CONTENTS

5 The Dynamic Layer . . . . . . . . . . . . . . . . . . . . . . . . . 61

The Role of the Player . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Emergence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Dynamic Mechanics . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Dynamic Aesthetics . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
Dynamic Narrative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Dynamic Technology . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

6 The Cultural Layer . . . . . . . . . . . . . . . . . . . . . . . . . 79

Beyond Play . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Cultural Mechanics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Cultural Aesthetics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Cultural Narrative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Cultural Technology . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Authorized Transmedia Are Not in the Cultural Layer . . . . . . . 85
The Cultural Impact of a Game . . . . . . . . . . . . . . . . . . . . . 86
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

7 Acting Like a Designer . . . . . . . . . . . . . . . . . . . . . . . 89

Iterative Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Innovation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Brainstorming and Ideation . . . . . . . . . . . . . . . . . . . . . . . 98
Changing Your Mind . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
Scoping!. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

8 Design Goals . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

Design Goals: An Incomplete List. . . . . . . . . . . . . . . . . . . 106
Designer-Centric Goals . . . . . . . . . . . . . . . . . . . . . . . . . 106
Player-Centric Goals . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
 CONTENTS xiii

9 Paper Prototyping . . . . . . . . . . . . . . . . . . . . . . . . 125

The Benefits of Paper Prototypes. . . . . . . . . . . . . . . . . . . 126
Paper Prototyping Tools . . . . . . . . . . . . . . . . . . . . . . . . 127
An Example of a Paper Prototype. . . . . . . . . . . . . . . . . . . 129
Best Uses for Paper Prototyping . . . . . . . . . . . . . . . . . . . 138
Poor Uses for Paper Prototyping . . . . . . . . . . . . . . . . . . . 139
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

10 Game Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . .141

Why Playtest? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Being a Great Playtester Yourself . . . . . . . . . . . . . . . . . . . 142
The Circles of Playtesters . . . . . . . . . . . . . . . . . . . . . . . . 143
Methods of Playtesting . . . . . . . . . . . . . . . . . . . . . . . . . 146
Other Important Types of Testing . . . . . . . . . . . . . . . . . . 152
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

11 Math and Game Balance . . . . . . . . . . . . . . . . . . . . 155

The Meaning of Game Balance . . . . . . . . . . . . . . . . . . . . 156
Installing Apache OpenOffice Calc . . . . . . . . . . . . . . . . . . 156
Examining Dice Probability with Calc . . . . . . . . . . . . . . . . 157
The Math of Probability . . . . . . . . . . . . . . . . . . . . . . . . . 165
Randomizer Technologies in Paper Games. . . . . . . . . . . . . 170
Weighted Distributions . . . . . . . . . . . . . . . . . . . . . . . . . 173
Permutations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Positive and Negative Feedback . . . . . . . . . . . . . . . . . . . 176
Using Calc to Balance Weapons . . . . . . . . . . . . . . . . . . . . 177
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183

12 Puzzle Design . . . . . . . . . . . . . . . . . . . . . . . . . . . 185

Puzzles Are Almost Everywhere. . . . . . . . . . . . . . . . . . . . 186
Scott Kim on Puzzle Design . . . . . . . . . . . . . . . . . . . . . . 186
Puzzle Examples in Action Games . . . . . . . . . . . . . . . . . . 193
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
xiv CONTENTS

13 Guiding the Player . . . . . . . . . . . . . . . . . . . . . . . . 197

Direct Guidance. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
Indirect Guidance. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
Teaching New Skills and Concepts . . . . . . . . . . . . . . . . . . 207
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210

14 The Digital Game Industry . . . . . . . . . . . . . . . . . . . .211

About the Game Industry. . . . . . . . . . . . . . . . . . . . . . . . 212
Game Education . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
Getting into the Industry . . . . . . . . . . . . . . . . . . . . . . . . 217
Don’t Wait to Start Making Games!. . . . . . . . . . . . . . . . . . 221
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222

Part II Digital Prototyping . . . . . . . . . . . . . . . . . . . . . . . . 223

15 Thinking in Digital Systems. . . . . . . . . . . . . . . . . . . 225

Systems Thinking in Board Games . . . . . . . . . . . . . . . . . . 226
An Exercise in Simple Instructions . . . . . . . . . . . . . . . . . . 226
Game Analysis: Apple Picker. . . . . . . . . . . . . . . . . . . . . . . . . 229
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234

16 Introducing Our Development Environment: Unity . . . 235

Downloading Unity . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
Introducing Our Development Environment . . . . . . . . . . . 237
Running Unity for the First Time . . . . . . . . . . . . . . . . . . . 241
Setting Up the Unity Window Layout . . . . . . . . . . . . . . . . 246
Learning Your Way Around Unity . . . . . . . . . . . . . . . . . . . 251
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251

17 Introducing Our Language: C#. . . . . . . . . . . . . . . . . 253

Understanding the Features of C# . . . . . . . . . . . . . . . . . . 254
Reading and Understanding C# Syntax . . . . . . . . . . . . . . . 259
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
 CONTENTS xv

18 Hello World: Your First Program . . . . . . . . . . . . . . . . 263

Creating a New Project . . . . . . . . . . . . . . . . . . . . . . . . . 264
Making a New C# Script . . . . . . . . . . . . . . . . . . . . . . . . . 266
Making Things More Interesting . . . . . . . . . . . . . . . . . . . 271
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279

19 Variables and Components. . . . . . . . . . . . . . . . . . . 281

Introducing Variables . . . . . . . . . . . . . . . . . . . . . . . . . . 282
Strongly Typed Variables in C# . . . . . . . . . . . . . . . . . . . . 282
Important C# Variable Types . . . . . . . . . . . . . . . . . . . . . . 283
The Scope of Variables . . . . . . . . . . . . . . . . . . . . . . . . . 286
Naming Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . 286
Important Unity Variable Types . . . . . . . . . . . . . . . . . . . . 288
Unity GameObjects and Components. . . . . . . . . . . . . . . . 294
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297

20 Boolean Operations and Conditionals . . . . . . . . . . . . 299

Booleans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
Comparison Operators . . . . . . . . . . . . . . . . . . . . . . . . . 303
Conditional Statements . . . . . . . . . . . . . . . . . . . . . . . . . 307
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313

21 Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .315
Types of Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
Set Up a Project . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
while Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
do...while Loops . . . . . . . . . . . . . . . . . . . . . . . . . . 319
for Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
foreach Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
Jump Statements within Loops . . . . . . . . . . . . . . . . . . . . 322
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
xvi CONTENTS

22 Lists and Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . 327

C# Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
Multidimensional Arrays . . . . . . . . . . . . . . . . . . . . . . . . 337
Jagged Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
Whether to Use Array or List . . . . . . . . . . . . . . . . . . . . . . 344
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
Summary Exercise . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
Moving Forward . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347

23 Functions and Parameters . . . . . . . . . . . . . . . . . . . 349

Set Up the Function Examples Project . . . . . . . . . . . . . . . 350
Definition of a Function . . . . . . . . . . . . . . . . . . . . . . . . . 350
Function Parameters and Arguments . . . . . . . . . . . . . . . . 353
Returning Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
Proper Function Names . . . . . . . . . . . . . . . . . . . . . . . . . 356
When Should You Use Functions? . . . . . . . . . . . . . . . . . . 356
Function Overloading . . . . . . . . . . . . . . . . . . . . . . . . . . 358
Optional Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
The params Keyword. . . . . . . . . . . . . . . . . . . . . . . . . . 359
Recursive Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362

24 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
Getting Started with Debugging . . . . . . . . . . . . . . . . . . . 364
Stepping Through Code with the Debugger. . . . . . . . . . . . 369
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377

25 Classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
Understanding Classes . . . . . . . . . . . . . . . . . . . . . . . . . 380
Class Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
 CONTENTS xvii

26 Object-Oriented Thinking . . . . . . . . . . . . . . . . . . . 391

The Object-Oriented Metaphor . . . . . . . . . . . . . . . . . . . . 392
An Object-Oriented Boids Implementation . . . . . . . . . . . . 394
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403

27 The Agile Mentality. . . . . . . . . . . . . . . . . . . . . . . . 405

The Manifesto for Agile Software Development . . . . . . . . . 406
Scrum Methodology . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
Creating Your Own Burndown Charts . . . . . . . . . . . . . . . . 416
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416

Part III Game Prototype Examples and Tutorials . . . . . . . . . . .417

28 Prototype 1: Apple Picker . . . . . . . . . . . . . . . . . . . . .419

The Purpose of a Digital Prototype. . . . . . . . . . . . . . . . . . 420
Preparing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
Coding the Apple Picker Prototype . . . . . . . . . . . . . . . . . 428
GUI and Game Management. . . . . . . . . . . . . . . . . . . . . . 440
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448
Next Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448

29 Prototype 2: Mission Demolition . . . . . . . . . . . . . . . 449

Getting Started: Prototype 2. . . . . . . . . . . . . . . . . . . . . . 450
Game Prototype Concept. . . . . . . . . . . . . . . . . . . . . . . . 450
Art Assets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451
Coding the Prototype . . . . . . . . . . . . . . . . . . . . . . . . . . 456
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485
Next Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485

30 Prototype 3: Space SHMUP . . . . . . . . . . . . . . . . . . 487

Getting Started: Prototype 3. . . . . . . . . . . . . . . . . . . . . . 488
Setting the Scene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490
Making the Hero Ship . . . . . . . . . . . . . . . . . . . . . . . . . . 491
Adding Some Enemies . . . . . . . . . . . . . . . . . . . . . . . . . 504
xviii CONTENTS

Spawning Enemies at Random . . . . . . . . . . . . . . . . . . . . 509

Setting Tags, Layers, and Physics . . . . . . . . . . . . . . . . . . . 510
Making the Enemies Damage the Player . . . . . . . . . . . . . . 513
Restarting the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
Shooting (Finally) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519
Adding Power-Ups . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
Resolving Race Conditions in Code . . . . . . . . . . . . . . . . . 538
Making Enemies Drop Power-Ups . . . . . . . . . . . . . . . . . . 541
Programming Other Enemies . . . . . . . . . . . . . . . . . . . . . 543
Adding Particle Effects and Background . . . . . . . . . . . . . . 556
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558
Next Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558

31 Prototype 4: Prospector Solitaire . . . . . . . . . . . . . . . 561

Getting Started: Prototype 4. . . . . . . . . . . . . . . . . . . . . . 562
Build Settings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 562
Importing Images as Sprites . . . . . . . . . . . . . . . . . . . . . . 564
Constructing Cards from Sprites . . . . . . . . . . . . . . . . . . . 566
The Prospector Game . . . . . . . . . . . . . . . . . . . . . . . . . . 583
Implementing Prospector in Code . . . . . . . . . . . . . . . . . . 585
Adding Scoring to Prospector . . . . . . . . . . . . . . . . . . . . . 604
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 619
Next Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620

32 Prototype 5: Bartok. . . . . . . . . . . . . . . . . . . . . . . . 621

Getting Started: Prototype 5. . . . . . . . . . . . . . . . . . . . . . 622
Build Settings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623
Coding Bartok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655
Next Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655
 CONTENTS xix

33 Prototype 6: Word Game . . . . . . . . . . . . . . . . . . . . 657

Getting Started: Word Game Prototype. . . . . . . . . . . . . . . 658
About the Word Game . . . . . . . . . . . . . . . . . . . . . . . . . 658
Parsing the Word List . . . . . . . . . . . . . . . . . . . . . . . . . . 660
Setting Up the Game . . . . . . . . . . . . . . . . . . . . . . . . . . 665
Laying Out the Screen . . . . . . . . . . . . . . . . . . . . . . . . . . 671
Adding Interactivity . . . . . . . . . . . . . . . . . . . . . . . . . . . 680
Adding Scoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 684
Adding Animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 687
Adding Color. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 690
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692
Next Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692

34 Prototype 7: QuickSnap . . . . . . . . . . . . . . . . . . . . . 695

Getting Started: QuickSnap Prototype . . . . . . . . . . . . . . . 696
Building the Scene . . . . . . . . . . . . . . . . . . . . . . . . . . . . 697
Coding the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 706
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 725
Next Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 726

35 Prototype 8: Omega Mage . . . . . . . . . . . . . . . . . . . 727

Getting Started: Omega Mage Prototype . . . . . . . . . . . . . 728
Building the Scene . . . . . . . . . . . . . . . . . . . . . . . . . . . . 730
The Mage Character . . . . . . . . . . . . . . . . . . . . . . . . . . . 735
Mouse Interaction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 737
Movement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 741
The Inventory and Selecting Elements . . . . . . . . . . . . . . . 747
Casting the Fire Ground Spell . . . . . . . . . . . . . . . . . . . . . 754
Changing Rooms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 764
Spawning Enemies . . . . . . . . . . . . . . . . . . . . . . . . . . . . 768
Abstracting the Enemy Interface . . . . . . . . . . . . . . . . . . . 782
xx CONTENTS

Making an EnemyFactory. . . . . . . . . . . . . . . . . . . . . . . . 785

Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 789
Next Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 789
Thanks! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 789

Part IV Appendices. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 791

A Standard Project Setup Procedure . . . . . . . . . . . . . . 793

B Useful Concepts . . . . . . . . . . . . . . . . . . . . . . . . . . 799

C# and Unity Coding Concepts . . . . . . . . . . . . . . . . . . . . 801
Math Concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 822
Interpolation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 831
Roleplaying Games. . . . . . . . . . . . . . . . . . . . . . . . . . . . 846
User Interface Concepts. . . . . . . . . . . . . . . . . . . . . . . . . 848

C Online Reference . . . . . . . . . . . . . . . . . . . . . . . . . 851

Tutorials . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 852
Unity Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 852
Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853
Searching Tips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 854
Finding Assets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 854
Educational Software Discounts . . . . . . . . . . . . . . . . . . . 855

Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 857
FOREWORD

I have a theory about game designers and teachers. I think that, beneath the possible differ-
ences of our outer appearances, we’re secretly the same; that many of the skills possessed by
a good game designer are the same skills held by a great teacher. Have you ever had a teacher
who held a class spellbound with puzzles and stories? Who showed you simple demonstrations
of skills that were easy for you to understand and copy, but were difficult for you to master?
Who gradually, cleverly, helped you put together pieces of information in your mind, maybe
without your even realizing it, until one day your teacher was able to step aside and watch you
do something amazing, something that you never would have thought was possible.

We video game designers spend a lot of our time finding ways to teach people the skills they
need to play our games, while keeping them entertained at the same time. We sometimes
don’t want people to be aware that we’re teaching them, though—the best tutorial levels that
video games open with are usually the ones that simply seem like the beginning of a thrilling
adventure. I was lucky to work at the award-winning game studio Naughty Dog for eight amaz-
ing years, where I was the Lead or Co-Lead Game Designer on all three PlayStation 3 games in
the Uncharted series. Everyone at the studio was very happy with the sequence that opened
our game Uncharted 2: Among Thieves. It effectively taught each player all the basic moves they
would need to play the game, while keeping them on the edge of their seat because of the
gripping predicament our hero Nathan Drake found himself in, dangling over the edge of a cliff
in a ruined train carriage.

Video game designers do this kind of thing over and over again as they create digital adven-
tures for us to play. Working on a sequence of player experiences like those found in the
Uncharted games, I have to stay very focused on what the player has recently learned. I have
to present my audience with interesting situations that use their new skills and that are easy
enough that they won’t get frustrated, but challenging enough that their interest will be held.
To do this with complete strangers, through the channels of communication that a game
provides—the graphics of the environments and the characters and objects within them, the
sounds that the game makes, and the interactivity of the game’s controls—is tremendously
challenging. At the same time, it is one of the most rewarding things I know how to do.

Now that I’ve become a professor, teaching game design in a university setting, I’ve discovered
firsthand just how many of the skills I developed as a game designer are useful in my teaching.
I’m also discovering that teaching is just as rewarding as game design. So it came to me as no
xxii FOREWORD

surprise when I discovered that Jeremy Gibson, the author of this book, is equally talented as a
game designer and a teacher, as you’re about to find out.

I first met Jeremy around ten years ago, at the annual Game Developers Conference in Northern
California, and we immediately hit it off. He already had a successful career as a game devel-
oper, and his enthusiasm for game design struck a chord with me. As you’ll see when you begin
to read this book, he loves to talk about game design as a craft, a design practice and an emerg-
ing art. Jeremy and I stayed in touch over the years, as he went back to graduate school at Carn-
egie Mellon University’s excellent Entertainment Technology Center to study under visionaries
like Doctor Randy Pausch and Jesse Schell. Eventually, I came to know Jeremy as a professor and
a colleague in the Interactive Media & Games Division of the School of Cinematic Arts at the
University of Southern California—part of USC Games, the program in which I now teach.

In fact, I got to know Jeremy better than ever during his time at USC—and I did it by becoming
his student. In order to acquire the skills that I needed to develop experimental research games
as part of USC’s Game Innovation Lab, I took one of Jeremy’s classes, and his teaching trans-
formed me from a Unity n00b with some basic programming experience into an experienced
C# programmer with a strong set of skills in Unity, one of the world’s most powerful, usable,
adaptable game engines. Every single one of Jeremy’s classes was not only packed with infor-
mation about Unity and C#, but was also peppered with inspirational words of wisdom about
game design and practical pieces of advice related to game development—everything from
his thoughts about good “lerping,” to great tips for time management and task prioritization,
to the ways that game designers can use spreadsheets to make their games better. I graduated
from Jeremy’s class wishing that I could take it again, knowing that there was a huge amount
more that I could learn from him.

So I was very happy when I heard that Jeremy was writing a book—and I became even happier
when I read the volume that you now hold in your hands. The good news for both you and me
is that Jeremy has loaded this book with everything that I wanted more of. I learned a lot in the
game industry about best practices in game design, production, and development, and I’m
happy to tell you that in this book, Jeremy does a wonderful job of summarizing those ways of
making games that I’ve found work best. Within these pages, you’ll find step-by-step tutorials
and code examples that will make you a better game designer and developer in innumerable
ways. While the exercises in this book might get complex—game design is among the most
difficult things I know how to do—Jeremy won’t ask you to do anything complicated without
guiding you through it in clear, easy-to-follow language.

You’ll also find history and theory in this book. Jeremy has been thinking deeply about game
design for a long time and is very well-read on the subject. In the first part of this volume,
you’ll find an extraordinarily wide and deep survey of the state-of-the-art in game design
theory, along with Jeremy’s unique and strongly developed synthesis of the very best ideas
 FOREWORD xxiii

he’s encountered on his game design travels. Jeremy supports his discussion with interesting
historical anecdotes and fascinating glimpses of the long traditions of play in human culture,
all of which help to frame his conversation in valuable and progressive ways. He continually
pushes you to question your assumptions about games, and to think beyond the console, the
controller, the screen and the speakers, in ways that might just spur a whole new generation of
game innovators.

Jeremy Gibson has moved on from USC, and now teaches at the University of Michigan Ann
Arbor, and I’m very happy for the generations of U-M students that he’ll lead to new under-
standings of the craft of game design in the coming years. This spring, when Jeremy walked
into the restaurant at the annual GDC alumni dinner hosted by the USC Games program, the
room full of our current and former students came alive with whoops and cheers and moments
later broke out into applause. That tells you a lot about what Jeremy Gibson is like as a teacher.
You’re lucky that, thanks to this book, he can now be your teacher too.

The world of game design and development is changing at a rapid rate. You can be part of this
wonderful world—a world unlike any other I know, and which I love with all my heart. You can
use the skills you learn through reading this book to develop new prototypes for new kinds of
games, and in doing so you might eventually create whole new genres of games, in expressive
new styles, which appeal to new markets. Some of tomorrow’s stars of game design are cur-
rently learning to design and program, in homes and schools all around the world. If you make
good use of this book, by following the advice and doing the exercises you find in here, it might
just help your chances of creating a modern game design classic.

Good luck, and have fun!

Richard Lemarchand
Associate Professor, USC Games
PREFACE

Welcome to Introduction to Game Design, Prototyping, and Development. This book is based on
my work over many years as both a professional game designer and a professor of game design
at several universities, including the Interactive Media and Games Division at the University of
Southern California and the Department of Electrical Engineering and Computer Science at the
University of Michigan Ann Arbor.

This preface introduces you to the purpose, scope, and approach of this book.

The Purpose of This Book

My goal in this book is quite simple: I want to give you all the tools and knowledge you need to
get started down the path to being a successful game designer and prototyper. This book is the
distillation of as much knowledge as I can cram into it to help you toward that goal. Unlike most
books out there, this book combines the disciplines of game design and digital development
(that is, computer programming) and wraps them both in the essential practice of iterative
prototyping. The emergence of advanced, yet approachable, game development engines such
as Unity has made it easier than ever before to create playable prototypes that express your
game design concepts to others, and the ability to do so will make you a much more skilled
(and employable) game designer.

The book is divided into four parts:

Part I: Game Design and Paper

Prototyping
The first part of the book starts by exploring various theories of game design and the analyti-
cal frameworks for game design that have been proposed by several earlier books. This section
then describes the Layered Tetrad as a way of combining and expanding on many of the best
features of these earlier theories. The Layered Tetrad is explored in depth as it relates to various
decisions that you must make as a designer of interactive experiences. This part also covers
information about the interesting challenges of different game design disciplines; describes the
process of paper prototyping, testing, and iteration; and gives you concrete information to help
you become a better designer.
 PREFACE xxv

Part II: Digital Prototyping

The second part teaches you how to program. This part draws upon my many years of experi-
ence as a professor teaching nontechnical students how to express their game design ideas
through digital code. If you have no prior knowledge or experience with programming or
development, this part is designed for you. However, even if you do have some programming
experience, you might want to take a look at this part to learn a few new tricks or get a refresher
on some approaches.

Part III: Game Prototype Examples

and Tutorials
The third part of the book encompasses several different tutorials, each of which guides you
through the development of a prototype for a specific style of game. The purpose of this part
is twofold: It reveals some best practices for rapid game prototyping by showing you how I
personally approach prototypes for various kinds of games, and it provides you with a basic
foundation on which to build your own games in the future. Most other books on the market
that attempt to teach Unity (our game development environment) do so by taking the reader
through a single, monolithic tutorial that is hundreds of pages long. In contrast, this book takes
you through several much smaller tutorials. The final products of these tutorials are necessarily
less robust than those found in some other books, but it is my belief that the variety of projects
in this book will better prepare you for creating your own projects in the future.

Part IV: Appendices

This book has several important appendices that merit mention here. Rather than repeat
information throughout the book or require you to go hunting through various chapters for it,
any piece of information that is referenced several times in the book or that I think you would
be likely to want to reference later (after you’ve finished reading the book once) is placed in
the appendices. Appendix A is just a quick step-by-step introduction to the initial creation
process for a game project in Unity. The second and longest appendix is Appendix B, “Useful
Concepts.” Though it has a rather lackluster name, this is the portion of the book that I believe
you will return to most often in the years following your initial read through the book. “Useful
Concepts” is a collection of several go-to technologies and strategies that I use constantly in my
personal game prototyping process, and I think you’ll find a great deal of it to be very useful.
The third and final appendix is a list of very useful online references where you can find answers
to questions not covered in this book. It is often difficult to know the right places to look for
help online; this appendix lists those that I personally turn to most often.
xxvi PREFACE

There Are Other Books Out There

As a designer or creator of any kind, I think that it’s absolutely essential to acknowledge those
on whose shoulders you stand. There have been many books written on games and game
design, and the few that I list here are those that have had the most profound effect on either
my process or my thinking about game design. You will see these books referenced many times
throughout this text, and I encourage you to read as many of them as possible.

Game Design Workshop by Tracy Fullerton

Initially penned by Tracy Fullerton, Chris Swain, and Steven S. Hoffman, Game Design Workshop
is now in its third edition. More than any other text, this is the book that I turn to for advice on
game design. This book was initially based on the Game Design Workshop class that Tracy and
Chris taught at the University of Southern California, a class that formed the foundation for the
entire games program at USC (and a class that I myself taught there from 2009–2013). The USC
Interactive Media and Games graduate program has been named the number one school for
game design in North America by Princeton Review every year that they have been ranking
game programs, and the Game Design Workshop book and class were the foundation for that
success.

Unlike many other books that speak volumes of theory about games, Tracy’s book maintains a
laser focus on information that helps budding designers improve their craft. I taught from this
book for many years (even before I started working at USC), and I believe that if you actually
attempt all the exercises listed in the book, you can’t help but have a pretty good paper game
at the end.

Fullerton, Tracy, Christopher Swain, and Steven Hoffman, Game Design Workshop: A Play-
centric Approach to Creating Innovative Games, 2nd ed. (Boca Raton, FL: Elsevier Morgan
Kaufmann, 2008)

The Art of Game Design by Jesse Schell

Jesse Schell was one of my professors at Carnegie Mellon University and is a fantastic game
designer with a background in theme park design gained from years working for Walt Disney
Imagineering. Jesse’s book is a favorite of many working designers because it approaches game
design as a discipline to be examined through 100 different lenses that are revealed through-
out the book. Jesse’s book is a very entertaining read and broaches several topics not covered
in this book.

Jesse Schell, The Art of Game Design: A Book of Lenses (Boca Raton, FL: CRC Press, 2008)
 PREFACE xxvii

The Grasshopper by Bernard Suits

While not actually a book on game design at all, The Grasshopper is an excellent exploration of
the definition of the word game. Presented in a style reminiscent of the Socratic method, the
book presents its definition of game very early in the text as the Grasshopper (from Aesop’s
fable The Ant and the Grasshopper) gives his definition on his deathbed, and his disciples spend
the remainder of the book attempting to critique and understand this definition. This book also
explores the question of the place of games and play in society.

Bernard Suits, The Grasshopper: Games, Life and Utopia (Peterborough, Ontario: Broadview
Press, 2005)

Game Design Theory by Keith Burgun

In this book, Burgun explores what he believes are faults in the current state of game design
and development and proposes a much narrower definition of game than does Suits. Burgun’s
goal in writing this text was to be provocative and to push the discussion of game design
theory forward. While largely negative in tone, Burgun’s text raises a number of interesting
points, and reacting to it helped me to refine my personal understanding of game design.

Keith Burgun, Game Design Theory: A New Philosophy for Understanding Games (Boca
Raton, FL: A K Peters/CRC Press, 2013)

Imaginary Games by Chris Bateman

Bateman uses this book to argue that games are a legitimate medium for scholarly study. He
pulls from several scholarly, practical, and philosophical sources; and his discussions of books
like Homo Ludens by Johan Huizinga, Man, Play, and Games by Roger Caillois, and the paper
“The Game Game” by Mary Midgley are both smart and accessible.

Chris Bateman, Imaginary Games (Washington, USA: Zero Books, 2011)

Level Up! by Scott Rogers

Rogers distills his knowledge from many years in the trenches of game development into a
book that is fun, approachable, and very practical. When he and I co-taught a level design class,
this was the textbook that we used. Rogers is also a comic book artist, and his book is full of
humorous and helpful illustrations that drive home the concepts of level, character, narrative,
and many other aspects of design.

Scott Rogers, Level up!: The Guide to Great Video Game Design (Chichester, UK: Wiley, 2010)
xxviii PREFACE

Our Digital Prototyping Environment:

Unity
All the digital game examples in this book are based on the Unity Game Engine and the C#
programming language. I have taught students to develop digital games and interactive
experiences for more than a decade, and in my experience, Unity is—by far—the best envi-
ronment that I have found for learning to develop games. I have also found that C# is the best
initial language for game prototypers to learn. Some other tools out there are easier to learn
and require no real programming (Game Maker and Game Salad are two examples), but Unity
allows you much more flexibility and performance in a package that is basically free (the free
version of Unity includes nearly all the capabilities of the paid version, and it is the version used
throughout this book). If you want to actually learn to program games, Unity is the engine you
want to use.

Similarly, some programming languages are a little more approachable than C#. In the past,
I have taught my students both ActionScript and JavaScript. However, C# is the one language
I have used that continually impresses me with its flexibility and feature set. Learning C# means
learning not only programming but also good programming practices. Languages such as
JavaScript allow a lot of sloppy behaviors that I have found actually lead to slower develop-
ment. C# keeps you honest (via things like strongly typed variables), and that honesty will not
only make you a better programmer but will also result in your being able to code more quickly
(for example, strong variable typing enables very robust code hinting and auto-completion,
which makes coding faster and more accurate).

Who This Book Is For

There are many books about game design, and there are many books about programming.
This book seeks to fill the gap between the two. As game development technologies like Unity
become more ubiquitous, it is increasingly important that game designers have the ability to
sketch their design ideas not only on paper but also through working digital prototypes. This
book exists to help you learn to do just that:

■ If you’re interested in game design but have never programmed, this book is perfect
for you. Part I introduces you to several practical theories of game design and presents you
with the practices that can help you develop and refine your design ideas. Part II teaches
you how to program from nothing to understanding object-oriented class hierarchies.
Since I became a college professor, the majority of my classes have focused on teaching
nonprogrammers how to program games. I have distilled all of my experience doing so
into Part II of this book. Part III takes you through the process of developing eight different
game prototypes across several different game genres. Each demonstrates fast methods to
get from concept to working digital prototype. Lastly, the appendices will explain specific
 PREFACE xxix

game development and programming concepts in-depth and guide you to resources to
learn more once you’ve finished the book. This in-depth content was moved largely to
Appendix B, “Useful Concepts,” so that you could continue to use that section of the book as
a reference in the years to come.
■ If you’re a programmer who is interested in game design, Parts I and III of this book
will be of most interest to you. Part I introduces you to several practical theories for game
design and presents you with the practices that can help you develop and refine your
design ideas. You can skim Part II, which introduces C# and how it is used in Unity. If you are
familiar with other programming languages, C# looks like C++ but has the advanced fea-
tures of Java. Part III takes you through the process of developing eight different game pro-
totypes across several different game genres. Game development in Unity is very different
from what you may be used to from other game engines. Many elements of development
are taken care of outside of the code. Each prototype will demonstrate the style of develop-
ment that works best in Unity to get from concept to working digital prototype quickly. You
will also want to look carefully at Appendix B, which is full of detailed information about
various development concepts and is arranged as a reference that you can return to later.

Conventions
This book maintains several writing conventions to help make the text more easily
understandable.

Any place that specific button names, menu commands, or other multi-word nouns are intro-
duced in the text, they will be listed in italics. This includes terms like the Main Camera Game
Object. An example menu command is Edit > Project Settings > Physics, which would instruct
you to select the Edit menu from the menu bar, choose the Project Settings sub-menu, and then
select Physics.

Book Elements
The book includes several different types of asides that feature useful or important information
that does not fit in the flow of the regular body text.

note
Callouts in this format are for information that is useful but not critical. Information
in notes will often be an interesting aside to the main text that provides a little bit
more info about the topic.
xxx PREFACE

t ip
This element provides additional information that is related to the book content
and can help you as you explore the concepts in the book.

warning
BE CAREFUL Warnings cover information about things that you need to be
aware of to avoid mistakes or other pitfalls.

SIDEBAR

The sidebar is for discussions of longer topics that are important to the text but should
be considered separately from it.

Code
Several conventions apply to the code samples in this book. When specific elements from the
code listing are placed in regular paragraph text, they appear in a monospaced font. The vari-
able variableOnNewLine from the following code listing is an example of this.

Code listings also utilize a monospaced font and appear as follows:

1 public class SampleClass {

2 public GameObject variableOnExistingLine; // 1
3 public GameObject variableOnNewLine; // 2
4 }

1 Code listings are often annotated; in this case, additional information about the line
marked with // 1 would appear in this first annotation.
2 Some code listings will be expansions on code that you’ve already written or that already
exists in the C# script file for another reason. In this case, the old lines will be at normal
weight, and the new lines will be at bold weight.
 PREFACE xxxi

Most of the code listings in the first two parts of the book will include line numbers (as seen in
the preceding listing). You do not need to type the line numbers when entering the code into
MonoDevelop (it will automatically number all lines). In the final part of the book, there are no
line numbers due to the size of the code listings.

Book Website
The website for this book includes all of the files referenced in the chapters, lecturer notes, and
finished versions of each tutorial prototype. It is available at http://book.prototools.net.
ACKNOWLEDGMENTS

A tremendous number of people deserve to be thanked here. First and foremost, I want to
thank my wife, Melanie, whose help and feedback on my chapters throughout the entire pro-
cess improved the book tremendously. I also want to thank my family for their many years of
support, with special thanks to my father for teaching me how to program as a child.

As a new author, there were several people at Pearson who provided support to me and
shepherded me through this process. Chief among them were Chris Zahn, Laura Lewin, Olivia
Basegio, Elaine Wiley, and Keith Cline who each demonstrated laudable patience in working
with me. I also had the support of some fantastic technical reviewers: Marc Destefano, Charles
Duba, and Margaret Moser. Their keen eyes and minds found many places in the original text
that could be clarified or improved.

I would also like to thank all the educators who have taught me and worked as my colleagues.
Special thanks go to Dr. Randy Pausch and Jesse Schell. Though I had worked as a professor and
game designer before meeting them, they each had a profound effect on my understanding of
design and education. I also owe tremendous thanks to Tracy Fullerton, Mark Bolas, and Scott
Fisher, who were friends and mentors to me in the years I taught at the University of Southern
California’s Interactive Media and Games Division. There were also many other brilliant faculty
and friends at USC who helped me to flesh out the ideas in this book, including Adam Liszkie-
wicz, William Huber, Richard Lemarchand, Scott Rogers, Vincent Diamante, Sam Roberts, and
Logan Ver Hoef.

Many of my friends in the industry have also helped me by giving me suggestions for the book
and feedback on the ideas presented therein. These included Michael Sellers, Nicholas For-
tugno, Jenova Chen, Zac Pavlov, Joseph Stevens, and many others.

Thanks as well to all the fantastic students whom I have taught over the past decade. It is you
who inspired me to want to write this book and who convinced me that there was something
important and different about the way that I was teaching game development. Every day that I
teach, I find myself inspired and invigorated by your creativity, intelligence, and passion.

Finally, I would like to thank you. Thank you for purchasing this book and for your interest in
developing games. I hope that this book helps you get started, and I would love to see what
you make with the knowledge you gain here.
ABOUT THE AUTHOR

Jeremy Gibson is a lecturer teaching computer game design for the Electrical Engineering
and Computer Science department at the University of Michigan Ann Arbor and is the founder
of ExNinja Interactive, LLC. From 2009 to 2013, he was an Assistant Professor teaching game
design and protyping for the Interactive Media and Games Division of the University of South-
ern California’s School of Cinematic Arts, which was the number one game design school in
North America throughout his tenure there. Jeremy serves the IndieCade independent game
festival as the Chair for Education and Advancement, where he is responsible for the IndieX-
change and GameU conference tracks, and he has spoken at the Game Developers Conference
every year since 2009.

Jeremy earned a Master of Entertainment Technology degree from Carnegie Mellon University’s
Entertainment Technology Center in 2007 and a Bachelor of Science degree in Radio, Televi-
sion, and Film from the University of Texas at Austin in 1999. Jeremy has worked as a program-
mer and prototyper for companies such as Human Code and frog design, has taught classes
for Great Northern Way Campus (in Vancouver, BC), Texas State University, the Art Institute of
Pittsburgh, Austin Community College, and the University of Texas at Austin, and has worked
for Walt Disney Imagineering, Maxis, and Electronic Arts/Pogo.com, among others. While in
graduate school, his team created the game Skyrates, which won the Silver Gleemax Award at
the 2008 Independent Games Festival. Jeremy also apparently has the distinction of being the
first person to ever teach game design in Costa Rica.
This page intentionally left blank
CH AP TE R 16

INTRODUCING
OUR DEVELOPMENT
ENVIRONMENT: UNITY

This is the start of your programming adventure.

In this chapter, you download Unity, the game

development environment that you will use
throughout the rest of this book. We talk about
why Unity is a fantastic game development tool for
any budding game designer or developer and why
we've chosen C# as the language for you to learn.

You also take a look at the sample project that

ships with Unity, learn about the various window
panes in the Unity interface, and move these panes
into a logical arrangement that will match the
examples you see in the rest of the book.
236 CHAPTER 16 INTRODUCING OUR DEVELOPMENT ENVIRONMENT: UNITY

Downloading Unity
First things first, let's start downloading Unity. The Unity installer is over 1 GB in size, so depend-
ing on your Internet speed, this could take anywhere from a few minutes to a couple of hours.
After you've gotten this process started, we can move on to talking about Unity.

As of this writing, the latest major version of Unity is Unity 4. Because Unity is under constant
development, the current minor version should be something like 4.x.y, with the x and y being
sub-version numbers. Regardless of version, Unity is always available for free from Unity's
official website:

http://unity3d.com/unity/download
This should take you to a page that provides the latest download link for your system (see Fig-
ure 16.1). Unity is available for both PC and OS X, and it is nearly identical on both platforms.

Figure 16.1 The web page to download Unity

tip
Unity is free, but you will still need to acquire a license, and this requires that you
have an available Internet connection the first time that you run the application.
 INTRODUCING OUR DEVELOPMENT ENVIRONMENT 237

Introducing Our Development

Environment
Before you can begin prototyping in earnest, you first need to become familiar with Unity, our
chosen development environment. Unity itself can really be thought of as a synthesis program;
while you will be bringing all the elements of your game prototypes together in Unity, the
actual production of the assets will largely be done in other programs. You will program in
MonoDevelop; model and texture in a 3D modeling program like Maya, Autodesk 3ds Max, or
Blender; edit images in a photo editor such as Photoshop or GIMP; and edit sound in an audio
program such as Pro Tools or Audacity. Because a large section of this book is about program-
ming and learning to program in C# (pronounced "see-sharp"), you'll be spending most of the
time with tutorials using MonoDevelop, but it's still critically important to understand how to
use Unity and how to effectively set up your Unity environment.

Why Choose Unity?

There are many game development engines out there, but we've chosen to focus on Unity for
several reasons:

■ Unity is free: With the free version of Unity, you can create and sell games that run on OS
X, PC, the Web, Linux, iOS, Android, BlackBerry, Windows Phone, Windows Store, and more.
While the Pro version of Unity includes a few additional useful features, for a game designer
just learning to prototype, the free version is really all that you need. The Pro version nor-
mally costs $1,500 (or $75/month), but if you're a student, a one-year license for Unity Pro is
about ten times less!

tip
STUDENT PRICING If you are a student, you can purchase a 1-year educational
license for Unity Pro at a tremendous discount (about $150 instead of $1,500). This
license does prevent you from being able to sell your game directly to players, but
it lets you use the full power of Unity Pro to develop your game and make excel-
lent portfolio pieces. After you're done developing, if you know you've got a hit on
your hands, you can purchase the commercial version of Pro before attempting to
sell your game. Unity has also recently added Pro student licenses that do allow
you to sell your games, but those have a higher cost.

To find the latest student pricing for Unity, I recommend searching the Web for
"unity educational student pricing." That will make sure that you're looking at the
latest.

■ Write once, deploy anywhere: The free version of Unity can build applications for OS X,
PC, the Web, Linux, iOS, Android, BlackBerry, Windows Phone, Windows Store, and more, all
from the same code and files. This kind of flexibility is at the core of Unity; in fact, it's what
the product and company are named for. There are also paid extensions to Unity Pro that
238 CHAPTER 16 INTRODUCING OUR DEVELOPMENT ENVIRONMENT: UNITY

professionals can use to create games for the PlayStation 3, Xbox 360, and several other
game consoles.
■ Great support: In addition to excellent documentation, Unity has an incredibly active
and supportive development community. Hundreds of thousands of developers are using
Unity, and many of them contribute to the discussions on Unity forums across the web.
■ It's awesome!: My students and I have joked that Unity has a "make awesome" button.
Although this is not strictly true, there are several phenomenal features built in to Unity
that will make your games both play and look better by simply checking an option box.
Unity engineers have already handled a lot of the difficult game programming tasks for
you. Collision detection, physics simulation, pathfinding, particle systems, draw call batch-
ing, shaders, the game loop, and many other tough coding issues are all included. All you
need to do is make a game that takes advantage of them!

Why Choose C#?

Within Unity, you have the choice to use any of three programming languages: UnityScript, C#,
or Boo. Very, very few people actually use Boo, so you're really left with two choices.

UnityScript, A Version of JavaScript

JavaScript is often seen as a language for beginners; it's easy to learn, the syntax is forgiving
and flexible, and it's also used for scripting web pages. JavaScript was initially developed in the
mid-1990s by Netscape as a "lite" version of the Java programming language. It was used as
a scripting language for web pages, though early on that often meant that various JavaScript
functions worked fine in one web browser but didn't work at all in another. The syntax of Java
Script was the basis for HTML5 and is very similar to Adobe Flash's ActionScript 3. Despite all of
this, it is actually JavaScript's flexibility and forgiving nature that make it an inferior language
for this book. As one example, JavaScript uses weak typing, which means that if we were to cre-
ate a variable (or container) named bob, we could put anything we wanted into that variable: a
number, a word, an entire novel, or even the main character of our game. Because the variable
bob doesn't have a variable type, Unity never really knows what kind of thing bob is, and that
could change at any time. These flexibilities in JavaScript make scripting more tedious and
prevent programmers from taking advantage of some of the most powerful and interesting
features of modern languages.

C#
C# was developed in 2000 as Microsoft's response to Java. They took a lot of the modern cod-
ing features of Java and put them into a syntax that was much more familiar to and comfort-
able for traditional C++ developers. This means that C# has all the capabilities of a modern
language. For you experienced programmers, these features include function virtualization
and delegates, dynamic binding, operator overloading, lambda expressions, and the powerful
Language INtegrated Query (LINQ) query library among many others. For those of you new
to programming, all you really need to know is that working in C# from the beginning will
make you a better programmer and prototyper in the long run. In my prototyping class at the
 INTRODUCING OUR DEVELOPMENT ENVIRONMENT 239

University of Southern California, I taught using both UnityScript and C# in different semesters,
and I found that students who were taught C# consistently produced better game prototypes,
exhibited stronger coding practices, and felt more confident about their programming abilities
than their peers who had been taught UnityScript in prior semesters of the class.

RUNTIME SPEED OF EACH LANGUAGE

If you've had some experience programming, you might assume that C# code in Unity
would execute faster than code written in JavaScript or Boo. This assumption would
come from the understanding that C# code is usually compiled while JavaScript and
Boo are interpreted (meaning that compiled code is turned into a computer's machine
language by a compiler as part of the coding process, while interpreted code is trans-
lated on-the-fly as the player is playing the game, making interpreted code generally
slower). However, in Unity, every time you save a file of C#, UnityScript, or Boo code,
Unity imports it, converts any of the three languages to the same Common Intermediate
Language (CIL), and then compiles that CIL into machine language. So, regardless of the
language you use, your Unity game prototypes will execute at the same speed.

On the Daunting Nature of Learning a Language

There's no way around it, learning a new language is tough. I'm sure that's one of the reasons
that you bought this book rather than just trying to tackle things on your own. Just like Spanish,
Korean, Mandarin, French, or any other human language, there are going to be things in C# that
don't make any sense at first, and there are places that I'm going to tell you to write something
that you don't immediately understand. There will also probably be a point where you are
just starting to understand some things about the language but feel utterly confused by the
language as a whole (which is the exact same feeling you'd have if you took one semester of
Spanish class and then tried to watch soap operas on Telemundo). This feeling comes for almost
all of my students about halfway through the semester, and by the end of the semester, every
one of them feels much more confident and comfortable with both C# and game prototyping.

Rest assured, this book is here for you, and if you read it in its entirety, you will emerge with
not only a working understanding of C# but also several simple game prototypes that you can
use as foundations on which to build your own projects. The approach that I take in this book
comes from many semesters of experience teaching "nonprogrammers" how to find the hidden
coder within themselves and, more broadly, how to convert their game ideas into working pro-
totypes. As you'll see throughout this book, that approach is composed of three steps:

1. Concept introduction: Before asking you to code anything for each project, I'll tell you
what we're doing and why. This general concept of what you're working toward in each
tutorial will give you a framework on which to hang the various coding elements that are
introduced in the chapter.
240 CHAPTER 16 INTRODUCING OUR DEVELOPMENT ENVIRONMENT: UNITY

2. Guided tutorial: You'll be guided step by step through a tutorial that will demonstrate
these concepts in the form of a playable game. Unlike some other approaches, we will be
compiling and testing the game throughout the process so that you can identify and repair
bugs (problems in the code) as you go, rather than trying to fix all of them at the end. Addi-
tionally, I'll even guide you to create some bugs so that you can see the errors they cause
and become familiar with them; this will make it easier when you encounter your own bugs
later.
3. Lather, rinse, repeat: In many tutorials, you'll be asked to repeat something. For instance,
in a top-down shooter game like Galaga, the tutorial would guide you through the process
of making one single enemy type, and then it would ask you to create three others on your
own. Don't skip this part! This repetition will really drive the concept home, and it will help
your understanding solidify later.

p ro tip
90% OF BUGS ARE JUST TYPOS I've spent so much time helping students fix
bugs that now I can very quickly spot a typo in code. The most common include
the following:

■ Misspellings: If you type even one letter wrong, the computer won't have
any idea what you're talking about.

■ Capitalization: To your C# compiler, A and a are two completely different let-

ters, so variable, Variable, and variAble are all completely different words.
■ Missing semicolons: Just like almost every sentence in English should end
in a period, nearly every statement in C# should end in a semicolon ( ; ). If
you leave the semicolon out, it will often cause an error on the next line. FYI:
A semicolon is used because the period was needed for decimal numbers
and what's called dot syntax in variable names and subnames (e.g., varName.
subVarName.subSubVarName).

Earlier, I mentioned that most of my students feel confused and daunted by C# at about the
midway point of the semester, and it's at exactly that time that I assign them the Classic Games
Project. They are asked to faithfully recreate the mechanics and game feel of a classic game
over the course of four weeks. Some great examples have included Super Mario Bros., Metroid,
Castlevania, Pokemon, and even the original Legend of Zelda. By being forced to work things out
on their own, to schedule their own time, and to dig deeply into the inner workings of these
seemingly simple games, the students come to realize that they understand much more C#
than they thought, and that is the time that everything really falls into place. The key compo-
nent here is that the thought process changes from "I'm following this tutorial" to "I want to
 RUNNING UNITY FOR THE FIRST TIME 241

do this...now how do I make it happen?" At the end of this book, you will be prepared to tackle
your own game projects (or your own Classic Game Project, if you want). The tutorials in this
book can be a fantastic starting point on which to build your own games.

Running Unity for the First Time

Hopefully reading all of that will have given Unity enough time to download in the background.
Congratulations! You're about to embark on a challenging but rewarding journey.

Installing Unity
Depending on your personal system settings, the Unity installer should have placed itself in a
Downloads folder somewhere on your hard drive. I'm sure you've done this kind of thing several
times before, so find the file, run the installer with all default options, and let's get to work. This
is a big install, so it could take a while. In the final bit of the installation, it may look like it has
frozen; but don't worry, just give it some time to complete.

Your First Launch: Licensing

The first time you run Unity, it will open a built-in web page that will ask you to create a license
and register (see Figure 16.2), but it's really quite painless, and it shouldn't take much time at all.
You will need to choose between the free license and a 30-day trial of Unity Pro. At this time,
I recommend activating the free version of Unity, especially if you plan to work through this
book slowly. The Pro version will be nice to have for the prototype you'll make in Chapter 34,
"QuickSnap," so I recommend waiting until then to start the 30-day trial of Unity Pro. However,
choosing the 30-day Unity Pro trial now would allow you to see the beautiful reflections and
depth-of-field shaders in Figure 16.4.

You can choose to activate the 30-day trial any time, although you can only activate it once, and
once the trial is over, you will be reverted to the free version. If you choose the free version now,
you can always go back and upgrade to the Pro trial by selecting Unity > Manage License from
the menu bar on OS X (on PC, choose Help > Manage License).

Once you click OK, you are prompted to create a Unity account. They'll send you an email to
confirm this (so you need to give them a valid email address). Then, you may be asked to take
part in a survey, which you can choose to skip if you want (through a link at the bottom of the
survey).

After this, Unity will automatically open the AngryBots demo project. This is a large project, so it
may take several seconds to load. It may appear that Unity has frozen or is unresponsive, but if
you wait a bit, everything will show up.
242 CHAPTER 16 INTRODUCING OUR DEVELOPMENT ENVIRONMENT: UNITY

Figure 16.2 Unity licensing window

Example Project: AngryBots

When you first launch Unity, it will open a demo project and will show you a Welcome to Unity
window that pops up over the main Unity window. For now, close the Welcome to Unity window,
but feel free to explore the introductory videos and other links there later if you want more of
an introduction to Unity than is provided in this chapter.

Unless you tell it not to (by holding the Option key at launch), Unity will open an existing
project every time you launch it. The default project for this is AngryBots (see Figure 16.3), a
game created internally by the Unity team to show off the capabilities of the engine. If for some
reason the default scene doesn't open automatically, you will need to double-click the Angry-
Bots Scene Asset to open it; it should be the first one listed in the Project window pane in the
bottom half of the screen. You'll see Project and several other window panes on screen that I'll
explain later, but for now, just click the large Play button at the top of the Unity window (the tri-
angle pointing to the right in the top, center of the Unity window) and enjoy playing this game
for a while. You can read about the controls for this game in the nearby tip.
 RUNNING UNITY FOR THE FIRST TIME 243

Figure 16.3 The Unity window when it opens for the first time

t ip
ANGRYBOTS CONTROLS

■ Movement is controlled by the W, A, S, and D or arrow keys.

■ The gun will always aim at your mouse pointer.

■ Hold down the left mouse button to fire.

You must stand very close to any circular door for a couple of seconds for it to
open.

There are several computers that you need to stand in front of in order to unlock
them (turn the color of electric wires coming out of them from red to green).

Here are some things to notice while you're playing:

■ Shaders: AngryBots is rife with shaders (see Figure 16.4), code written specifically for the
graphics card with the sole purpose of making the game look amazing. Special ones to
check out include the following:
A. The depth-of-field image effect that makes some parts of the scene in-focus while
others are out-of-focus (see letter A in Figure 16.4). This will only appear in Unity Pro.
244 CHAPTER 16 INTRODUCING OUR DEVELOPMENT ENVIRONMENT: UNITY

B. The reflections on the floors (especially of the laser sight) (see letter B in Figure 16.4).
This will only appear in Unity Pro.
C. The animated water droplets on the floor when outside (see letter C in Figure 16.4). This
appears regardless of whether you are using Unity Pro or free.
As explained earlier, if you chose to activate the free license rather than the 30-day Unity Pro
trial, you will not see the most advanced shaders. This is one of the few differences between the
free and Pro versions of Unity.

Figure 16.4 Screen showing the effects of various shaders

■ Character rigging and animation: Unity makes use of animation blending to enable the
player character to walk in one direction while looking and shooting in another.
■ AI pathing: Enemies will move around objects in a room to find and attack the player.

Feel free to explore the whole space and see what elements of AngryBots you might want to
use in your own project. Go ahead, I'll wait.

...

...
 RUNNING UNITY FOR THE FIRST TIME 245

So, what did you think? Did you blow up the base, or did you escape the exploding station? Did
you find the white museum? The controls of this game are a little unusual, but regardless, it's a
good showcase for how beautiful Unity can look.

Now, let's do something really cool.

Compile and Deploy AngryBots for the Web

Once you've clicked the blue Stop button at the top of the Unity window (the square next to the
Play button), choose File > Build Settings from the menu bar (meaning that you should choose
the item Build Settings from the File menu, as shown in Figure 16.5).

Figure 16.5 Build Settings menu selection

You should see the Build Settings window shown in Figure 16.6.

From here, be sure to click Web Player on the left and then check Offline Deployment in the Web
Player options area. Click Build and Run, and Unity will ask you where to save the files. Type
AngryBots Web Build for the filename and click Save.

Unity will process this for a while and build a web version of the game for you. Once it's built,
your web browser will automatically be opened and sent to the page you just made as shown
in Figure 16.7. Depending on your browser, you may be prompted to give the Unity plug-in
permission to run.
246 CHAPTER 16 INTRODUCING OUR DEVELOPMENT ENVIRONMENT: UNITY

Figure 16.6 Unity build settings for the web player

And there you go. You've compiled AngryBots for the web. Unity makes things like this very easy
so that you can focus on the interesting work: game design and development.

Setting Up the Unity Window Layout

The last thing we need to do before we start actually making things in Unity is to get our
environment laid out properly. Unity is very flexible, and one of those flexibilities is that it
allows you to arrange its window panes however you like. You can see several window layouts
by choosing various options from the Layout pop-up menu in the top-right corner of the Unity
window (see Figure 16.8).
 SETTING UP THE UNITY WINDOW LAYOUT 247

Figure 16.7 AngryBots running in a browser window

Figure 16.8 Position of the Layout pop-up menu and selection of the 2 by 3 layout
248 CHAPTER 16 INTRODUCING OUR DEVELOPMENT ENVIRONMENT: UNITY

Choose 2 by 3 from this pop-up menu. This will be the starting point for making our layout.

Before doing anything else, let's make the Project pane look a little cleaner. Click on the options
pop-up for the Project pane (shown in the black circle in Figure 16.9) and choose One Column
Layout.

Figure 16.9 Choosing the One Column Layout for the Project pane

Unity enables you to both move window panes around and adjust the borders between them.
As shown in Figure 16.10, you can move a pane by dragging its tab (the arrow cursor) or adjust a
border between panes by dragging the border between them (the left-right resize cursor).

Figure 16.10 Two types of cursors for moving and resizing Unity's window panes

When you drag a pane by its tab, a small ghosted version will appear (see Figure 16.11). Some
locations will cause the pane to snap into place. When this happens, the ghosted version of the
tab will appear in the new location.
 SETTING UP THE UNITY WINDOW LAYOUT 249

Snapped Ghosted
Pane Pane

Figure 16.11 Ghosted and snapped panes when moving them around the Unity window

Play around with moving the window panes until your window looks like Figure 16.12.

Figure 16.12 Proper layout for the Unity window...but it's still missing something
250 CHAPTER 16 INTRODUCING OUR DEVELOPMENT ENVIRONMENT: UNITY

Now the last thing we need to add is the Console pane. From the menu bar, choose Window >
Console. Then drag the Console pane below the Hierarchy pane. You'll also need to move the
Project pane after you've done this to create the final layout shown in Figure 16.13.

Figure 16.13 Final layout of the Unity window, including the Console pane

Now you just need to save this layout in the Layout pop-up menu so that you don't have to
go through all that again. Click the Layout pop-up menu and choose Save Layout, as shown in
Figure 16.14.

Figure 16.14 Saving the layout

This page intentionally left blank
INDEX

Numbers selecting elements from inventory, 749-754

spawning enemies, 768-782
3D animation/model resources, 854-855 puzzles in, 188
3D printing, touch as an Inscribed Layer boss fights, 195
aesthetic, 47-48 chain reaction puzzles, 194
physics puzzles, 194
sliding blocks/position puzzles, 193
A stealth puzzles, 194
A Pattern Language, 45 traversal puzzles, 194
AAA (top) games, costs in developing, 213 action lists (GameObjects), Apple Picker game
Achiever player type (diamonds), 67 analysis, 231-232
acquaintances as playtesters, 145 actions
action, five-act dramatic narrative structures discernable actions (meaningful play), 64
falling action (Act IV), 51 integrated actions (meaningful play), 64-65
rising action (Act II), 51 tracking and reacting to (empathetic
action games characters versus avatars), 57
Omega Mage Activision, Kaboom! game analysis (systems
changing rooms, 764-768 thinking), 229-234
creating an inventory, 747-754 Adkinson, Peter
creating the game environment, 730-735 innovation and the design process, 97-98
customizing setup, 789 RoboRally, 97-98
damaging enemies, 772-777 ADL (Automated Data Logging) and
damaging players, 777-782 playtesting, 151
enemy factories, 785-789 Adobe software, educational software
enemy interfaces, 782-785 discounts, 855
EnemyBug GameObjects, 770-780 Aeon of Strife, game mods and cultural
EnemySpiker GameObjects, 780-782 mechanics, 81-82
example of play, 728-729 aesthetics
fire ground spell, 754-762 Cultural Layer (Layered Tetrad), 82
fire spell, 761-762 cosplay, 82
fire-and-forget spells, 762-764 defining, 35
ground spell, 756-761 fan art, 82
importing Unity asset packages, 729 gameplay as art, 83
Mage GameObject (player character), Dynamic Layer (Layered Tetrad), 70
735-737 defining, 34
mouse interaction, 737-747 environmental aesthetics, 70, 73-74
project setup, 729 procedural aesthetics, 70-73
858 AESTHETICS

Elemental Tetrad framework, 27-28 animation

Inscribed Layer (Layered Tetrad), 46 Bartok digital prototype, 623
conveying information, 48-49 model resources and, 854-855
conveying mood, 48 procedural animation, 72
defining, 33 Word Game, 687-690
five aesthetic senses, 47-48 antagonism (Act II), three-act dramatic narrative
goals of aesthetic design, 48-49 structure, 52
hearing, 47 Apache OpenOffice Calc. See Calc
immediacy of sound (Inscribed Layer Apple Picker, 419
aesthetics), 47 Apple GameObject, 424-425
smell, 48 AppleTree GameObject, 421-423
touch, 47-48 art assets, 421-425
vision, 47 Basket GameObject, 425
MDA framework, 21-24 C# coding, 425-426
Snakes and Ladders, 21-24 adding high scores, 445-448
Agile software development methodologies, adding points, 441-442
405-407, 416 basic movement, 431-432
Agon (competitive play), Le Jeux et Le Hommes catching apples, 439-440
and the four different kinds of play, 110 changing direction, 432-434
Aguilar, Chris, and Vectorized Playing destroying baskets, 444-445
Cards 1.3 dropped apple notifications, 443-444
Bartok, 622 dropping apples, 434-435
Prospector Solitaire, 562 Game Over screen, 448
Alea (chance-based play), Le Jeux et Le Hommes GUI and game management, 440-448
and the four different kinds of play, 110 increasing difficulty, 448
Alexander, Christopher, and the purpose of instantiating baskets, 437-438
space (inscribed game mechanics), 45 moving baskets via mouse, 438-439
alpha phase (project development score counter, 440-441
process), 103 setting physics layers, 435-436
ambiguous decisions, importance of, 121 Start screen, 448
analysis phase (iterative design), 90-91 stopping apples from falling too far, 437
audience, determining, 91 camera setup, 425-426
fastest path to testing, determining, 92 game analysis (systems thinking), 229
prior art, researching, 92 GameObject action lists, 231-232
repetition, importance of, 96-97 GameObject flowcharts, 232-234
resources, determining, 91-92 GameObjects, 230-231
analyzing game play (playtesting) in Bartok gameplay, 230
questions, asking, 7 preparing for, 421
rounds, comparing, 9 project setup, 420
AND operator (&&) in C# coding, 300 time-based games, 431-432
Anderson and intent versus execution, ARG (Alternate Reality Games)
Nels, 187 Assassin, 17
AngryBots, Unity project example, 242-246 boundary mechanics, 44
Animal Crossing, fulfilling play as a player-centric Majestic, 17
goal of game design, 110
 AVATARS 859

arrays (C# coding), 328, 333-344 Assassin's Creed

basic array creation, 333-334 player guidance, 202, 205
converting limited possibilities and interactive or linear
arrays to lists, 336-337 narrative, 53-54
lists to arrays, 331 resolution (screen), 73
empty elements Assassin's Creed IV: Black Flag
foreach loops and, 335 experiences and space (Inscribed Layer
empty elements within arrays, 334-335 mechanics), 46
jagged arrays, 340-342 player guidance, 199
lists versus, 344 premises narratives, examples of, 49
methods, 336 asset packages (Unity)
multidimensional arrays, 337-340 Prospector Solitaire, 562
properties, 336 QuickSnap, 696-697
static methods, 336 Space SHMUP, 488-490
zero indexed arrays, 331 Assets folder (Unity), 265-266
arrows, indirectly guiding players by, 202-203 assigning tasks in burndown charts, 414-415
art AT (Automated Testing), 153
art assets, 854 Atkinson, Kevin, on word lists and
fan art (cultural aesthetics), 82 Word Game, 660
gameplay as art (cultural aesthetics), 83 Atlas Games, Lunch Money and house rules
prior art, researching (analysis phase of (dynamic mechanics), 67
iterative design), 92 attention and involvement as player-centric
procedural visual art, 71-72 goals of design, 118-120
Art of Game Design: A Book of Lenses, audience, determining (analysis phase of
The, 4, 11, 20, 27 iterative design), 91
guiding players indirectly, 200-206 audio assets, Unity Asset Store, 854
interest as a player-centric goal of audio design, indirectly guiding players
design, 119 by, 204-205
listening during design phase (iterative auditory play environments (environmental
design), importance of, 93 aesthetics), 73-74
Ten Rules of Probability Every Game Designer noisy environments, 74
Should Know, 165-169 volume control, 74
testing phase (iterative design), 96 AutoDesk software, educational software
Art of Puzzle Design, The discounts, 855
eight steps of puzzle design, 191-192 autotelic empowerment as a player-centric goal
genres of puzzles, 187-188 of design, 116-117
goals of effective design, 192-193 avatars
reasons for playing puzzles, 189 empathetic characters versus (interactive
required modes of thought in solving, 189 versus linear narrative), 55-57
aspect ratios multiple dialogue choices, 56-57
QuickSnap, 697 role fulfillment, 56
Space SHMUP, 490 silent protagonists, 56
Assassin, 17 tracking and reacting to player
actions, 57
guiding players indirectly by, 205
860 AVERAGE DAMAGE (WEAPONS AND GAME BALANCE)

average damage (weapons and game balance) weighted distributions, 173-175

calculating, 179 weighted probabilities, 174-175
charting, 179-180 Bartle, Richard, and types of players, 67-68
axis mapping Bartok, 4-5
InputManager (Unity), 491-494 analyzing game play, 7
Microsoft controllers, 848-849 deblocking, 6-7
digital prototype, building, 621-622, 655
backgrounds, 622-623
B build settings, 623-624
card animation, 623
balance (game design) and math, 183
creating cards, 624-629
balance, defining, 156
fanning the hand, 638-640
Calc, installing, 156-157
game logic, 653-655
dice probability, determining with Calc,
layouts, 629-638
157-158
LINQ (Language Integrated Query) and C#
adjusting column widths, 160
coding, 640-641
charting results, 164
managing initial deal, 642-643
counting die roll sums, 163-164
managing turns, 646-653
creating Die A row, 160-161
moving cards, 641-642
creating Die B row, 161-162
rules of the game, 622
creating probability distribution
sorting order (2D-depth), 643-646
charts, 164
digital version, obtaining, 4-5
creating rows, 159
dynamic procedures, 64
entering data in cells, 158-159
objective, 5
labeling rows, 162-163
playtesting, 6-10
spreadsheets, creating, 158
riffle shuffling, 7
summing dice role results, 163
rounds, comparing, 9
permutations, 175-176
rules of, 5, 8
positive/negative feedback, 176-177
Bateman, Chris
randomization
games, defining, 15
custom card decks, 172
Ilinx (vertigionous play), 110
dice, 170
Imaginary Games, 15, 110, 115-116
playing cards, 171-173
structured conflict as a player-centric goal of
shuffling decks, 172-173
design, 115-116
spinners, 170
BDV (Burndown Velocity) and burndown charts,
Ten Rules of Probability Every Game Designer
414-416
Should Know, 165-169
Beale, Alan, on word lists and Word Game, 660
weapons, balancing, 177-178
Beck, Kent, Manifesto for Agile Software
average damage, 179-180
Development, 406-407
Chapter 9 prototype example, 182-183
behavioral change, designing games for, 109
determining percent chance for each
Bejeweled 2, 186
bullet, 178
beta phase (project development
duplicating weapon data, 180-181
process), 103
showing overall damage, 181
rebalancing weapons, 177-178
showing overall damage, 181
 BULLETS, DETERMINING PERCENT CHANCE OF TO HIT (WEAPONS AND GAME BALANCE) 861

beta tests (playtesting) Boids project (OOP in C# coding), 394

closed playtesting, 150 building simple models, 394-396
limited playtesting, 150 project setup, 394
open playtesting, 150-151 scripts, 397-403
Bethesda Softworks Book of Games: Strategies, Tactics & History,
actions (players), tracking and reacting The, 22
to (empathetic characters versus bool variables (C# coding), 283
avatars), 57 Boolean operations (C# coding), 299-300, 313
Creation Kit, game mods and cultural bitwise Boolean operators, 302, 801-802
mechanics, 82 combining, 302-303
Fallout 3, side quests, 54 logical equivalence of, 303
Skyrim AND operator (&&), 300
conflicting objectives (Inscribed layer NOT operator (!), 300
mechanics), 42 OR operator (||), 300
final outcomes (dynamic mechanics), 69 shorting operators versus non-shorting
game mods and cultural mechanics, 82 operators, 301-302
importance of objectives (Inscribed layer boss fights as puzzles, 195
mechanics), 42 Botermans, Jack
narrative game mods, 83 Book of Games: Strategies, Tactics & History,
side quests, 54 The, 22
Bézier curves, 841-843 Snakes and Ladders, 22
recursive Bézier curves, 844-845 boundaries
reserve functions and, 815 ARG, 44
Bioware FDD framework, 25
Mass Effect Inscribed Layer (Layered Tetrad), 40, 44
multiple dialogue choices (empathetic Box Collider component (GameObjects),
characters versus avatars), 57 272, 295
player interaction patterns, 43 brainstorming (ideation), 98
Star Wars: Knights of the Old Republic, limited collection phase, 99
possibilities and interactive or linear collision phase, 100-101
narrative, 53-54 discussions, 101
bitwise Boolean operators (C# coding), expansion phase, 98-99
302, 801-802 rating phase, 101
Blade Runner, multiple dialogue choices Brice, Mattie, and Mainichi
(empathetic characters versus avatars), 57 experiential understanding as a
Blender software, educational software player-centric goal of design, 122-123
discounts, 855 personal expression/communication as a
Blizzard goal of game design, 108
Starcraft, game mods and cultural bridge puzzles, 188
mechanics, 81-82 brightness. See also color
Warcraft III, game mods and cultural environmental aesthetics (Dynamic
mechanics, 81-82 Layer), 73
board games, systems thinking, 226 indirectly guiding players by (contrast), 204
Bogost, Ian, and the magic circle concept and Brigs, Jeff, and music in C.P.U. Bach, 71
lusory attitude, 112 bullets, determining percent chance of to hit
(weapons and game balance), 178
862 BUNGIE AND HALO

Bungie and Halo Bézier curves and reserve functions, 815

inscribed dramatics, example of, 58 Boolean operations, 299-300, 313
limited possibilities and interactive or linear bitwise Boolean operators, 302, 801-802
narrative, 53-54 combining, 302-303
prior art, researching (analysis phase of logical equivalence of, 303
iterative design), 92 AND operator (&&), 300
Red vs. Blue, machinima example, 83-84 NOT operator (!), 300
Burgun, Keith OR operator (||), 300
ambiguous decisions, importance of, 121 shorting operators versus non-shorting
fun in game design, the importance of, operators, 301-302
109-110 C# 4.0 Pocket Reference, 854
Game Design Theory: A New Philosophy for camelCase naming conventions, 286
Understanding Games, 11, 83, 118 classes, 379-380, 390
gameplay as art (cultural aesthetics), 83 elements of, 380-381
games, defining, 11, 14-15 Enemy Class sample project, 381-384,
interesting decisions as a player-centric goal 387-388
of design, 120-121 inheritance, 387-389
performative empowerment as a instances, 289-288
player-centric goal of design, 118 instances as GameObject components,
burndown charts, 409 385-387
assigning tasks, 414-415 naming conventions, 287
BDV (Burndown Velocity), 414-416 properties, 384-385
creating, 416 subclasses, 388-389
estimated hours versus real hours, 413 superclasses, 388-389
example of, 410-412 collections, 327-328
prioritizing tasks, 414-415 arrays, 328, 333-337
button mapping, Microsoft controllers, 848-849 jagged arrays, 340-342
jagged lists, 342-344
lists, 328-333
C multidimensional arrays, 337-340
comparison statements, 299, 303, 313
C#, 253, 262
Greater Than comparison
arrays, 328, 333, 344
operator (>), 306
basic array creation, 333-334
Greater Than or Equal To comparison
converting arrays to lists, 336-337
operator (>=), 306-307
converting lists to arrays, 331
Is Equal To comparison operator
empty elements and foreach loops, 335
(==), 304
empty elements within arrays, 334-335
Less Than comparison operator (<), 306
jagged arrays, 340-342
Less Than or Equal To comparison operator
lists versus arrays, 344
(<=), 306-307
methods, 336
Not Equal To comparison operator
multidimensional arrays, 337-340
(!=), 306
properties, 336
compiled language, C# as, 254-256
static methods, 336
conditionals, 299, 307
zero indexed arrays, 331
if statements, 307-310
switch statements, 310-313
 C# 863

coroutines, 660, 802-803 lists, 328-331, 344

CSharp Yellow Book, 854 arrays versus lists, 344
debugging, 363-364 converting arrays to lists, 336-337
attaching debugger to Unity, 372-374 converting lists to arrays, 331
attaching/removing scripts, 366-367 jagged lists, 342-344
compile-time bugs, 364-366 methods, 331
QuickSnap, 713-714 properties, 331
runtime errors, 367-369 zero indexed lists, 331
stepping through code, 369-371, 373-377 loops, 315, 325
variables, 375-376 do.while loops, 316, 319-320
Enemy Class sample project for loops, 316, 320-322, 342
class inheritance, 387-388 foreach loops, 316, 322, 335
project setup, 381-384 infinite loops, 317-318
enum, 500, 803-804 jump statements in loops, 322-324
equality testing, 304 modulus operator (%), 324
features of (overview), 254 project setup, 300-301
function delegates, 525-531, 805-807 types of, 316
functions, 257-258, 349-350, 362 while loops, 316-319
defining, 350-353 managed code, C# as, 256
naming, 287, 356 modulus operator (%), 324
optional parameters, 359 MonoDevelop editor, creating C# scripts,
overloading, 358 266-271
parameters and arguments, 353-354 naming conventions, 286-287, 810
params keyword, 359-361 online resources, 853-854
reasons for using, 356-357 OOC (Object-Oriented Coding), C#
recursive functions, 361-362 as, 258-259
returning values, 354-356 OOP (Object-Oriented Programming),
static functions, 288 391, 403
void, returning, 355-356 Boids project, 394-403
GameObjects, 293-294 defining through metaphors, 392-393
Box Collider component, 295 operator precedence, 810
Capsule Collider component, 295 order of operations, 810
Collider components, 295-296 race conditions, 811-814
Mesh Collider component, 295 reasons for choosing, 238-239
Mesh Filter component, 295 reserve functions, 814-815
Renderer component, 295 runtime speed, 239
RigidBody component, 296 scripts
scripts as GameObject components, attaching to scene Main Camera, 797-798
296-297 creating, 266-271, 797
Sphere Collider component, 295 elements of, 380-381
Transform component, 294-295 GameObject components, scripts as,
interfaces, 782-785, 807-810 296-297
LINQ (Language Integrated Query) search tips, 854
and, 640-641
864 C#

software design patterns, 815 dice probability, determining, 157-158

Factory design pattern, 816 adjusting column widths, 160
Singleton design pattern, 815-816 charting results, 164
Strategy design pattern, 816-817 counting die roll sums, 163-164
strongly typed language, C# as, 256-257 creating Die A row, 160-161
subclasses, 589-592 creating Die B row, 161-162
superclasses, 591 creating probability distribution charts, 164
syntax of, 259-260 creating rows, 159
systems thinking and, 227 entering data in cells, 158-159
time-based games, 431-432 labeling rows, 162-163
tips for learning, 239-241 spreadsheets, creating, 158
Unity, online resources, 853-854 summing dice role results, 163
variables, 256-257, 282 FLOOR formula, weighted probabilities,
bool variables, 283 174-175
char variables, 285 formula editing, exiting, 164
class variables, 286 Function Wizard
color variables, 290-291 creating rows, 160-161
debugging C# coding, 375-376 MOD formula, 160-161
declaring, 282-283 INDEX formula, weighted probabilities,
defining, 282-283 174-175
equality testing, 304 installing, 156-157
float variables, 284 RAND formula, weighted probabilities,
instance variables, 289 174-175
int variables, 284 REPT formula, showing overall damage
literal values, 282-283 (weapons and game balance), 181
mathf variables, 292 ROUND formula, showing overall damage,
naming conventions, 286-287 (weapons and game balance), 181
private variables, 287 SUM formula, showing overall damage
quaternion variables, 291-292 (weapons and game balance), 181
scope of, 286, 817-820 weapons, balancing, 177-178
screen variables, 292 average damage, 179-180
string variables, 285 Chapter 9 prototype example, 182-183
SystemInfo variables, 293 duplicating weapon data, 180-181
types of, 283-286 overall damage, showing, 181
Unity variables, 287-294 percent chance for each bullet,
Vector3 variables, 288-290 determining, 178
XML and, 817-821 rebalancing weapons, 177-178
Caillois, Roger, on Le Jeux et Le Hommes and the weighted probabilities, 174-175
four different kinds of play, 110 Call of Duty, limited possibilities and interactive
Calc or linear narrative, 53-54
charts, creating, 164 Call of Duty: Modern Warfare, researching prior
COUNTIF formula, weighted probabilities, art (analysis phase of iterative design), 92
174-175 calls to action, directly guiding players by, 199
 CHARACTERS 865

camelCase naming conventions giving player feedback on scores, 616-619

(C# coding), 286 gold cards, 620
camera setups importing images as sprites, 564-566
Apple Picker, 425-426 importing Unity asset packages, 562
follow cameras, 462-466 matching drawn cards, 600-604
indirectly guiding players by, 203 mine tableau layout, 585-592
Mission Demolition, 451-453, 462-466 mobile device build settings, 562-563, 620
orthographic cameras, 425-426 positioning cards on tableau, 592-594
perspective cameras, 425-426 project setup, 562
Space SHMUP, 490 rules of the game, 583-584
campaigns (RPG), tips for running, 846-847 scoring, 604-619
Capsule Collider component setting up sorting layers on tableau,
(GameObjects), 295 594-597
card games shuffling cards, 581-583
Bartok, 621-622, 655 Prospector Solitaire, 561
backgrounds, 622-623 randomization, 171-173
build settings, 623-624 riffle shuffling, 7
card animation, 623 shuffling, 7, 172-173
creating cards, 624-629 Vectorized Playing Cards 1.3
fanning the hand, 638-640 Bartok, 622
game logic, 653-655 Prospector Solitaire, 562
layouts, 629-638 careers in the digital game industry, 217
LINQ (Language Integrated Query) and C# following up, 218-219
coding, 640-641 interviewing, 219-220
managing the initial deal, 642-643 networking, 217-218
managing turns, 646-653 salaries, 220
moving cards, 641-642 Cash, Brian
rules of the game, 622 Skyrates, 111
sorting order (2D-depth), 643-646 sporadic-play games and lusory attitude,
custom card decks, 172 111-112
Poker cells (calc spreadsheets)
game balance and, 176-177 adjusting column widths, 160
Red Dead Redemption rule mechanics, 44 entering data, 158-159
art assets, 614-615 MOD formula, 160-161
backgrounds, 614-615 SUM formula, 163
beginning/end of round announcements, chain reaction puzzles, 194
615-616 chance-based play (Alea), Le Jeux et Le Hommes
chain scoring, 605-607 and the four different kinds of play, 110
clickable card functionality, 597-600 changing
creating cards from sprites, 566-581 direction, Apple Picker, 432-434
displaying scores to players, 607-614 your mind (design process), 101
draw and discard actions, 597-604 char variables (C# coding), 285
earning points, 604-605 characters
example of play, 584-585 empathetic characters versus avatars
game logic, 597-604 (interactive versus linear narrative), 55-57
866 CHARACTERS

FDD framework, 26 climaxes

Inscribed Layer (Layered Tetrad), 49 Red Dead Redemption, 53
NPC, development of (interactive five-act dramatic narrative structures, 51
narratives), 55 three-act dramatic narrative structure, 53
charts (Calc) closed playtesting (beta tests), 150
average damage (weapons and game Clover Studios and Okami
balance), 179-180 empathetic characters versus avatars, 56
creating, 164 touch as an Inscribed Layer aesthetic, 48
Cheap Ass Games, touch as an Inscribed Layer code libraries and systems thinking, 228
aesthetic, 47 collaborators (player roles), 43
Cheater player type, 68 collection phase (brainstorming/ideation), 99
Chen, Jenova collections (C# coding), 327-328
flow as a player-centric goal of design, 113 arrays, 328, 333, 344
Journey, 144-145 basic array creation, 333-334
tissue playtesters, 144-145 converting arrays to lists, 336-337
chess puzzles, 188 converting lists to arrays, 331
Chief Plenty-Coups and coup-counting as a empty elements and foreach loops, 335
game, structured conflict as a player-centric empty elements within arrays, 334-335
goal of design, 115-116 jagged arrays, 340-342
Chowanec John, on fortune as a goal of game lists versus arrays, 344
design, 107 methods, 336
Chrono Trigger, limited possibilities and multidimensional arrays, 337-340
interactive or linear narrative, 53-54 properties, 336
Chutes and Ladders, 26 static methods, 336
Cialdini, Robert B., and Influence: The Psychology zero indexed arrays, 331
of Persuasion, 4 lists, 328-331, 344
citizens (player roles), 44 arrays versus lists, 344
Civilization, tables, 40-41 converting arrays to lists, 336-337
class variables (C# coding) converting lists to arrays, 331
classes (C# coding), 379-380, 390. See also OOP jagged lists, 342-344
(Object-Oriented Programming) in C# methods, 331
elements of, 380-381 properties, 331
Enemy Class sample project zero indexed lists, 331
inheritance, 387-388 colleges/universities, Games Education
project setup, 381-384 Programs, 215-217
inheritance, 387-388 Collider components (GameObjects), 272,
instances, 289-288, 385-387 295-296
naming conventions, 287 Collins on XP (Experience Points) and
properties, 384-385 cumulative outcomes (dynamic mechanics),
subclasses, 388-389 Andy, 69
superclasses, 388-389 collision phase (brainstorming/ideation),
clear decisions as part of player-centric 100-101
design, 122
 COSINE/SINE 867

color. See also brightness compiling

color variables (C# coding), 290-291 AngryBots, Unity project example, 245-246
colorblindness, player considerations compile-time bugs, debugging in C# coding,
(environmental aesthetics), 74 364-366
indirectly guiding players by, 204 complex problems, breaking down (systems
Word Game, 690-692 thinking), 229
columns (calc spreadsheets) computer languages and systems thinking, 227
adjusting widths, 160 Concept of Flow, 113-114, 116-117
labeling rows, 162-163 concepts
combat and gameplay development (paper developing concepts (paper prototyping),
prototyping) 129-130
control points, capturing, 137 new concepts, teaching by player
counterattacks, 135 guidance, 207
cover, 136 integration, 209
health, 136 sequencing, 207-209
interception fire, 137 conditionals (C# coding), 299, 307
weapons/firing, 134-135 if statements, 307-310
communication (personal) as a goal of game switch statements, 310-313
design, 108 conferences
community as a goal of game design, careers in the digital game industry, 217-218
107-108, 120 items to take when attending, 218
comparison statements (C# coding), conflict (structured) as a player-centric goal of
299, 303, 313 design, 115-116
Greater Than comparison operator (>), 306 conflicting objectives (Inscribed layer
Greater Than or Equal To comparison mechanics), 42
operator (>=), 306-307 Conrad, Joseph, The Heart of Darkness as an
Is Equal To comparison operator (==), 304 example of inscribed dramatics, 57-58
Less Than comparison operator (<), 306 Console pane (Unity), 251
Less Than or Equal To comparison operator constraints, indirectly guiding players by, 200
(<=), 306-307 construction puzzles, 188
Not Equal To comparison operator (!=), 306 contrast (brightness), indirectly guiding players
competition by, 204
Agon (competitive play), LeJeux et Le control points and gameplay development
Hommes and the four different kinds of (paper prototyping), capturing, 137
play, 110 controllers (Microsoft)
multilateral competition (player interaction axis mapping, 848-849
patterns), 43 button mapping, 848-849
player roles, 43 cooperative play (player interaction
team competition (player interaction patterns), 43
patterns), 43 Core War, example of player's role in game
unilateral competition (player interaction design, 62
patterns), 43 coroutines (C# coding), 663, 802-803
cosine/sine, 822-825
868 COSPLAY (CULTURAL AESTHETICS

cosplay (cultural aesthetics), 82 narrative, 83

costs of AAA (top) game development, 213 defining, 36
Counter Strike, game mods and cultural fan fiction as cultural narrative, 83
mechanics, 81-82 game mods as cultural narrative, 83
counterattacks, gameplay development (paper machinima, 83-84
prototyping), 135 technology, 84
COUNTIF formula (Calc), weighted probabilities, defining, 36
174-175 external tools (player-built) and cultural
coup-counting, structured conflict as a technology, 84-85
player-centric goal of design, 115-116 game technology used in other fields, 84
cover in gameplay development (paper transmedia, 85-86
prototyping), determining, 136 cumulative outcomes (dynamic mechanics), 69
C.P.U. Bach, music in, 71 custom card decks, 172
Crazy Cakes, ADL (Automated Data Logging) custom game levels (cultural mechanics), 82
and playtesting, 151
Creation Kit (Bethesda Softworks), game mods
and cultural mechanics, 82 D
crossword puzzles, 188
damage, weapons and game balance
CSharp Yellow Book, 854
average damage
Csíkszentmihályi, Mihaly
calculating, 179
autotelic empowerment as a player-centric
charting, 179-180
goal of design, 116-117
overall damage, showing, 181
Concept of Flow, 113-114, 116-117
deblocking in Bartok, 6-7
flow as a player-centric goal of design,
debugging C# coding, 363-364
113-114
attaching debugger to Unity, 372-374
Flow: The Psychology of Optimal Experience,
attaching/removing scripts, 366-367
114, 116-117
compile-time bugs, 364-366
Cultural Layer (Layered Tetrad), 34-35, 37-38,
QuickSnap, 713-714
79, 87
runtime errors, 367-369
aesthetics, 82
stepping through code, 369-371, 373-377
cosplay, 82
variables, 375-376
defining, 35
decimals and probability, 165-166
fan art, 82
decision-making as a player-centric goal of
gameplay as art, 83
design, 120-122
cultural impact of games, 86-87
ambiguous decisions, importance of, 121
defining, 80-81
clear decisions, 122
designer responsibilities, 37
double-edged decisions, 121
law and cultural impact of games, 86-87
meaningful play (dynamic procedures)
mechanics, 81
discernable actions, 121
custom game levels, 82
integrated actions, 121
defining, 35
novel decisions, 121
game mods, 81-82
 DESIGN PHASE (ITERATIVE DESIGN) 869

decks of cards Prospector Solitaire, 561

Bartok, 621-622, 655 randomization, 171-173
backgrounds, 622-623 riffle shuffling, 7
build settings, 623-624 shuffling, 7, 172-173
card animation, 623 Vectorized Playing Cards 1.3
creating cards, 624-629 Bartok, 622
fanning the hand, 638-640 Prospector Solitaire, 562
game logic, 653-655 Defense of the Ancients, game mods and cultural
layouts, 629-638 mechanics, 81-82
LINQ (Language Integrated Query) and C# degrees (colleges/universities), Games
coding, 640-641 Education Programs, 215-217
managing the initial deal, 642-643 delegates (function) in C# coding, 805-807
managing turns, 646-653 Demo Projects section (Unity website), 852
moving cards, 641-642 denouement (Act V), five-act dramatic narrative
rules of the game, 622 structures, 51
sorting order (2D-depth), 643-646 deploying AngryBots, Unity project example,
custom card decks, 172 245-246
art assets, 614-615 design goals, 105-106, 124
backgrounds, 614-615 designer-centric goals, 106
beginning/end of round announcements, community, 107-108
615-616 fame, 107
chain scoring, 605-607 fortune, 107
clickable card functionality, 597-600 greater good, 108-109
creating cards from sprites, 566-581 personal development/experience, 109
displaying scores to players, 607-614 personal expression/communication, 108
draw and discard actions, 597-604 player-centric goals, 106
earning points, 604-605 attention and involvement, 118-120
example of play, 584-585 empowerment, 116-118
game logic, 597-604 experiential understanding, 122-123
giving player feedback on scores, 616-619 fiero, the concept of, 110
gold cards, 620 flow, 113-115
importing images as sprites, 564-566 fun, 109-110
importing Unity asset packages, 562 interesting decisions, 120-122
matching drawn cards, 600-604 lusory attitude, 110-112
mine tableau layout, 585-592 structured conflict, 115-116
mobile device build settings, 562-563, 620 Design Patterns
positioning cards on tableau, 592-594 software design patterns, 815
project setup, 562 Factory design pattern, 816
rules of the game, 583-584 Singleton design pattern, 815-816
scoring, 604-619 Strategy design pattern, 816-817
setting up sorting layers on tableau, spawning enemies/enemy factories, 769-770
594-597 design phase (iterative design), 90
shuffling cards, 581-583 listening, importance of, 92-94
repetition, importance of, 96-97
870 DESIGNERS

designers, 89 lusory attitude, 110-112

Agile software development methodologies, structured conflict, 115-116
405-407, 416 project development process, 102
brainstorming (ideation), 98 alpha phase, 103
collection phase, 99 beta phase, 103
collision phase, 100-101 gold phase, 103
discussions, 101 post-release phase, 103
expansion phase, 98-99 preproduction phase, 102
rating phase, 101 production phase, 102-103
burndown charts, 409 responsibilities within Layered Tetrad
assigning tasks, 414-415 frameworks
BDV (Burndown Velocity), 414-416 Cultural Layer, 37
creating, 416 Dynamic Layer, 36-37
estimated hours versus real hours, 413 Inscribed Layer, 36
example of, 410-412 scoping and the design process, 103-104
prioritizing tasks, 414-415 Scrum software development
changing your mind (design process), 101 methodologies, 407, 416
designer-centric goals of design, 106 meetings, 409
community, 107-108 product backlogs/feature lists, 408
fame, 107 releases/sprints, 408
fortune, 107 teams, 408
greater good, 108-109 development environments. See Unity
personal development/experience, 109 development process (projects), 102
personal expression/communication, 108 Agile software development methodologies,
ideation (brainstorming), 98 405-407, 416
collection phase, 99 alpha phase, 103
collision phase, 100-101 beta phase, 103
discussions, 101 burndown charts, 409
expansion phase, 98-99 assigning tasks, 414-415
rating phase, 101 BDV (Burndown Velocity), 414-416
innovation, 97-98 creating, 416
iterative design, 90 estimated hours versus real hours, 413
analysis phase, 90-92 example of, 410-412
design phase, 90 prioritizing tasks, 414-415
implementation phase, 90-91 gold phase, 103
testing phase, 91 post-release phase, 103
overscoping (design process), 103-104 preproduction phase, 102
player-centric goals of design, 106 production phase, 102-103
attention and involvement, 118-120 Scrum software development
empowerment, 116-118 methodologies, 407, 416
experiential understanding, 122-123 meetings, 409
fiero, the concept of, 110 product backlogs/feature lists, 408
flow, 113-115 releases/sprints, 408
fun, 109-110 teams, 408
interesting decisions, 120-122
 DPS (DAMAGE PER SECOND) CALCULATORS 871

Diaconis, Persi, 7 digital systems thinking, 225, 234

dialogue Apple Picker game analysis, 229
immediacy of sound (Inscribed Layer GameObject action lists, 231-232
aesthetics), 47 GameObject flowcharts, 232-234
multiple dialogue choices (empathetic GameObjects, 230-231
characters versus avatars), 56-57 gameplay, 230
Diamante, Vincente, and music in Flower, 71 board games, 226
dice probability, determining with Calc, 157-158 breaking down complex problems into
cells (Calc spreadsheets), entering data in, simpler ones, 229
158-159 code libraries, 228
charting results, 164 computer languages, 227
counting die roll sums, 163-164 development environment, 228
probability distribution charts, creating via simple instructions exercise, 226-227
Calc, 164 direction in Apple Picker, changing, 432-434
randomization, 170 directionality (contrast), indirectly guiding
rows (Calc spreadsheets) players by, 204
adjusting column widths, 160 directly guiding players
creating Die A row, 160-161 Assassin's Creed IV: Black Flag, 199
creating Die B row, 161-162 Grand Theft Auto V, 199
creating rows, 159 Kya: Dark Legacy, 198
labeling rows, 162-163 Legend of Zelda: Ocarina of Time, 199
spreadsheets, creating, 158 methods of, 199
summing dice role results, 163 calls to action, 199
Unity example, 825-829 instructions, 199
difficulty, increasing, Apple Picker, 448 maps/guidance systems, 199
digital game industry, 211-212, 222 pop-ups, 199
changes to, 213 quality of guidance, determining, 198
costs of AAA (top) game development, 213 Skyrim, 198
freemium games, 214 Valkyrie Chronicles, 198
indie games, 214 discernable actions (meaningful play), 64, 121
working conditions, 213 discounts (educational software), 855
Entertainment Software Association Disneyland, indirect guidance example, 202
Essential Facts list, 212 distributions (weighted) and game balance,
Games Education Programs, 215-217 173-175
getting into (careers in), 217 Doctor Who, foreshadowing and interactive
following up, 218-219 narrative, 55
interviewing, 219-220 dot product, 829-830
networking, 217-218 double-edged decisions as part of player-centric
salaries, 220 design, 121
projects do.while loops (C# coding), 316, 319-320
joining, 221 downloading, Unity, 236
starting, 221-222 DPS (Damage Per Second) calculators,
digital prototypes, purpose of, 420 player-built external tools as example of
cultural technology, 84
872 DRAMATIC ELEMENTS (FDD FRAMEWORK)

Dramatic elements (FDD framework), 24-26 Dynamic elements (FDD framework), 24, 26-27
characters, 26 Emergence, 26-27
premises, 25-26 Emergent Narrative, 27
stories, 26 playtesting, 27
dramatic narrative structures Dynamic Layer (Layered Tetrad), 33-34,
dynamic dramatics, 75 37, 61, 77
emergent narrative, 76-77 aesthetics, 70
interactive narrative, 75-76 defining, 34
five-act dramatic narrative structure environmental aesthetics, 70, 73-74
climax (Act III), five-act dramatic narrative procedural aesthetics, 70-73
structures, 51 designer responsibilities, 36-37
denouement (Act V), five-act dramatic dramatics, 75
narrative structures, 51 emergent narrative, 76-77
exposition (Act I), five-act dramatic interactive narrative, 75-76
narrative structures, 50-51 emergence
falling action (Act IV), five-act dramatic Bartok, 63
narrative structures, 51 mechanics and unexpected emergence,
rising action (Act II), five-act dramatic 63-64
narrative structures, 51 mechanics
inscribed dramatics, purposes of, 57-58 defining, 34, 64
three-act dramatic narrative structure house rules, 66-67
antagonism (Act II), 52 meaningful play, 64-65
climaxes, 53 outcomes, 69
exposition (Act I), 52 player intent, 67-68
Field, Syd, 51-52 players, types of, 67-68
first plot point, 52 procedures, 64
Foundations of Screenwriting, The, 51-52 strategy, 65-66
hooks, 52 narrative, defining, 34
inciting incidents, 52 player's role in game design, 62-63
resolution (Act III), 52 technology, 34, 77
second plot point, 52
Star Wars: A New Hope as an example
of, 51-52 E
Dungeons & Dragons, 846
editing formulas (Calc spreadsheets), 164
dynamic dramatics, 75-77
education
Emergent Narrative (FDD framework), 27
Games Education Programs, 215-217
interactive versus linear narrative, 55
educational software discounts, 855
progression tables, 46
Electronic Arts
tips for running good campaigns, 846-847
Crazy Cakes, ADL (Automated Data Logging)
XP (Experience Points) and cumulative
and playtesting, 151
outcomes (dynamic mechanics), 69
Majestic, boundary mechanics, 44
duplicating weapon data (game balance),
180-181
 EXTRAPOLATION (LINEAR) 873

Elemental Tetrad framework (ludology), headaches, 74

20, 27-29 migraines, 74
aesthetics, defining, 27-28 visual play environments, 73
mechanics, defining, 27 brightness, 73
story's role in, 28 resolution (screen), 73
technology's role in, 28 environments (procedural), 73
Elite Beat Agents, music in, 71 epilepsy, player considerations (environmental
emergence aesthetics), 74
Dynamic Layer equipment (required), paper prototyping and
Bartok, 63 gameplay development, 132
mechanics and unexpected emergence, Ernst, James, on touch as an Inscribed Layer
63-64 aesthetic, 47
FDD framework, 26-27 estimated hours versus real hours (burndown
Emergent Narrative (FDD framework), 27, 76-77 charts), 413
emotion, evoking Eve Online, player-built external tools as
dynamic dramatics, Planetfall, 76 example of cultural technology, 84-85
inscribed dramatics, 57 Evil Hat Productions and FATE system, 846
empathetic characters versus avatars interactive versus linear narrative, 55
(interactive versus linear narrative) tips for running good campaigns, 846-847
actions (players), tracking and reacting to, 57 expansion phase (brainstorming/ideation),
multiple dialogue choices, 56-57 98-99
role fulfillment, 56 experience
silent protagonists, 56 personal experience/development,
employment in the digital game industry, 217 designing games for, 109
following up, 218-219 shared experiences, developing
interviewing, 219-220 relationships through (dynamic
networking, 217-218 dramatics), 76
salaries, 220 space and experience (Inscribed Layer
empowerment as a player-centric goal of mechanics), 46
design, 116-118 XP (Experience Points) and cumulative
Enemy Class sample project, project setup, 381 outcomes (dynamic mechanics), 69
engaging play as a player-centric goal of game experiential understanding as a player-centric
design, 110 goal of design, 122-123
enjoyable play as a player-centric goal of game Explorer player type (spades), 67
design, 110 exposition (Act I)
enum (C# coding), 501, 803-804 five-act dramatic narrative structures, 50-51
enumerating and probability, 166 three-act dramatic narrative structure, 52
environmental aesthetics (Dynamic Layer), expressing yourself through game design
70, 73 (designer-centric goals), 108
auditory play environments, 73-74 external tools (player-built) and cultural
noisy environments, 74 technology, 84-85
volume control, 74 extrapolation (linear), 835-837
player considerations, 74
colorblindness, 74
epilepsy, 74
874 FABLE, LIMITED POSSIBILITIES AND INTERACTIVE OR LINEAR NARRATIVE

F feel, designing for, 9-10

Fellowship of the Ring, emergent narrative
Fable, limited possibilities and interactive or example, 77
linear narrative, 53-54 Field, Syd
Facade, autotelic empowerment as a Foundations of Screenwriting, The, 51-52
player-centric goal of design, 117 three-act dramatic structure, 51-52
Factory software design pattern, 816 fiero, the concept of (player-centric game
falling action (Act IV), five-act dramatic narrative design), 110
structures, 51 Final Fantasy III (U.S. release), NPC
Fallout 3, side quests, 54 development, 55
fame as a goal of game design, 107 Final Fantasy VI (Japanese release), NPC
fan art (cultural aesthetics), 82 development, 55
fan fiction as cultural narrative, 83 Final Fantasy VII
Farmville empathetic characters versus avatars, 56
lusory attitude and, 111-112 final outcomes (dynamic mechanics),
spoilage mechanic, 112 example of, 69
Farscape, foreshadowing and interactive limited possibilities and interactive or linear
narrative, 55 narrative, 53-54
fastest path to testing, determining (analysis Final Fantasy X, limited possibilities and
phase of iterative design), 92 interactive or linear narrative, 53-54
FATE system, 846 final outcomes (dynamic mechanics), 69
interactive versus linear narrative, 55 firing weapons, gameplay development (paper
tips for running good campaigns, 846-847 prototyping), 134-135, 137-138
FDD framework (ludology), 20, 24, 29 first plot point (three-act dramatic narrative
defining, 24 structure), 52
Dramatic elements, 24-26 five-act dramatic narrative structure
characters, 26 climax (Act III), 51
premises, 25 denouement (Act V), 51
purposes of, 26 exposition (Act I), 50-51
stories, 26 falling action (Act IV), 51
Dynamic elements, 24, 26-27 rising action (Act II), 51
Emergence, 26-27 float variables (C# coding), 284
Emergent Narrative, 27 Flocks, Herds, and Schools: A Distributed Behavior
playtesting, 27 Model, OOP (Object-Oriented
Formal elements, 24-25 Programming), 393
boundaries, 25 FLOOR formula (Calc), weighted probabilities,
objectives, 25 174-175
outcomes, 25 flow
player interaction patterns, 24 Flow: The Psychology of Optimal Experience,
procedures, 25 114, 116-117
resources, 25 flow as a player-centric goal of design,
rules, 25 113-115
feature lists/product backlogs (Scrum software space and flow (Inscribed Layer
development methodologies), 408 vmechanics), 45
feedback (positive/negative), game balance,
176-177
 FULFILLING PLAY AS A PLAYER-CENTRIC GOAL OF GAME DESIGN 875

flowcharts (GameObjects) fortune as a goal of game design, 107

Apple Picker game analysis, 232-234 Foundations of Screenwriting, The, and the
frames as, 232 three-act dramatic structure, 51-52
Flower, music in, 71 FPS (First-Person Shooter) games
Flurry Analytics, freemium games, 214 QuickSnap, 695
focus testing, 152 adding sound/visual effects to shots,
follow cameras, Mission Demolition, 462-466 723-725
font-related resources, 855 aspect ratios, 697
for loops (C# coding), 316, 320-322, 342 build settings, 696
force-quitting applications, 317-318 camera setup, 702-705
OS X, 371 comparing shots, 717-721
Windows, 371-372 customizing setup, 725-726
foreach loops (C# coding), 316, 322, 335 debugging, 713-714
foreshadowing and interactive narrative, 55 deleting shots, 714-715
Formal elements (FDD framework), 24-25 displaying player progress, 721-723
boundaries, 25 first-person controllers, 697-698
objectives, 25 GUI elements, 703-705
outcomes, 25 importing Unity asset packages, 696-697
player interaction patterns, 24 layers, 703-705
procedures, 25 lightmapping, 698-701
resources, 25 maximizing target window, 716-717
rules, 25 project setup, 696
formal group playtesting method, 146-147 quality settings, 701-702
formal individual playtesting method, 147-148 recording player progress, 721-723
labs, 148-149 replacing shots, 715-716
running playtests, 149 setting up, 706-707
formulas (Calc spreadsheets) storing shots, 707-712
COUNTIF formula, weighted probabilities, fractions and probability, 165-166
174-175 frames
entering into cells, 158-159 defining, 232
exiting formula editing, 164 flowcharts (GameObjects), 232
FLOOR formula, weighted probabilities, free will versus plot (interactive versus linear
174-175 narratives), 53-55
INDEX formula, weighted probabilities, freemium games, 214
174-175 free-to-play games, 214
MOD formula, 160-161 Frequency, music in, 70-71
RAND formula, weighted probabilities, Freytag, Gustav
174-175 five-act dramatic structure, 50-51
REPT formula, overall damage, showing Technique of Dramas, The, 50-51
(weapons and game balance), 181 friends as playtesters, 144
ROUND formula, overall damage, showing fulfilling play as a player-centric goal of game
(weapons and game balance), 181 design, 110
SUM formula, 163
overall damage, showing (weapons and
game balance), 181
876 FULLERTON, TRACY

Fullerton, Tracy
dynamic mechanics, 64
G
FDD framework, 20, 24, 29 game balance and math, 155, 183
boundaries, 25 balance, defining, 156
characters, 26 Calc, installing, 156-157
Dramatic elements, 24-26 dice probability, determining with Calc,
Dynamic elements, 24, 26-27 157-158
Emergence, 26-27 adjusting column widths, 160
Emergent Narrative, 27 charting results, 164
Formal elements, 24-25 counting die roll sums, 163-164
objectives, 25 creating Die A row, 160-161
outcomes, 25 creating Die B row, 161-162
player interaction patterns, 24 creating probability distribution charts, 164
playtesting, 27 creating rows, 159
premises, 25-26 entering data in cells, 158-159
procedures, 25 labeling rows, 162-163
resources, 25 spreadsheets, creating, 158
rules, 25 summing dice role results, 163
stories, 26 Unity example, 825-829
Game Design Workshop, 10, 13, 20, 24, 64 permutations, 175-176
player interaction patterns, 43 positive/negative feedback, 176-177
games, defining, 10, 13 randomization
inscribed mechanics, 40 custom card decks, 172
player interaction patterns, 43 dice, 170
fun in game design, the importance of playing cards, 171-173
(player-centric game design goals), 109-110 shuffling decks, 172-173
function delegates (C# coding), 525-531, spinners, 170
805-807 Ten Rules of Probability Every Game Designer
Function Wizard (Calc) Should Know, 165-169
MOD formula, 160-161 weapons, balancing, 177-178
rows, creating, 160-161 average damage, 179-180
functions (C# coding), 257-258, 349-350, 362 Chapter 9 prototype example, 182-183
defining, 350-353 determining percent chance for each
naming, 286, 356 bullet, 178
overloading, 358 duplicating weapon data, 180-181
parameters overall damage, showing, 181
arguments and parameters, 353-354 rebalancing weapons, 177-178
optional parameters, 359 weighted distributions, 173-175
params keyword, 359-361 weighted probabilities, 174-175
reasons for using, 356-357 Game Design Theory: A New Philosophy for
recursive functions, 361-362 Understanding Games, 11
returning gameplay as art (cultural aesthetics), 83
values, 354-356 performative empowerment as a
void,, 355-356 player-centric goal of design, 118
static functions, 288 Game Design Workshop, 10, 13, 18, 20, 24, 43
 GAMEOBJECTS 877

Game Feel: A Game Designer's Guide to Virtual Mesh Filter component, 272, 295
Sensation, digital prototypes, 420 Mesh Renderer component, 272
Game Game, The, 15-16 Mission Demolition
game industry (digital), 211-212, 222 adding levels, 479-485
changes to, 213 C# coding, 456-485
costs of AAA (top) game development, 213 camera setup, 451-453
freemium games, 214 castles, 471-473
indie games, 214 clouds, 467-471
working conditions, 213 directional light GameObject, 451
Entertainment Software Association follow cameras, 462-466
Essential Facts list, 212 game logic, 479-485
Games Education Programs, 215-217 ground GameObject, 451
getting into (careers in), 217 hitting the goal, 478-479
following up, 218-219 instantiating projectiles, 458-462
interviewing, 219-220 projectile component, 455-456
networking, 217-218 projectile trails, 456-462
salaries, 220 returning shots, 473-474
projects slingshot GameObject, 453-455
joining, 221 slingshots, 456-462
starting, 221-222 vection/sense of speed, 466-471
game mods Omega Mage
cultural mechanics, 81-82 EnemyBug GameObjects, 770-780
narrative game mods, 83 EnemySpiker GameObjects, 780-782
Game Over screen, Apple Picker, 448 Mage GameObject (player character),
Game pane (Unity), 251 735-737
game play analysis (playtesting) and Bartok playing, 272-273
questions, asking, 7 prefabs, 273-277
rounds, comparing, 9 Renderer component, 295
GameCareerGuide.com, game developer salary RigidBody component, 272, 296
surveys, 220 scripts as GameObject components, 296-297
GameObjects, 281, 293-294 Space SHMUP
Apple Picker, 230-231 adding elements, 559-560
Apple GameObject, 424-425 adding enemies, 543-556
AppleTree GameObject, 421-423 art assets, enemies, 504-506
Basket GameObject, 425 aspect ratios, 490
GameObject action lists, 231-232 boosting weapons, 531-538
GameObject flowcharts, 232-234 camera bounds, 498-500
Box Collider component, 272, 295 camera setup, 490
Capsule Collider component, 295 damaging players, 513-518
class instances as GameObject components directional light GameObject, 490
(C# coding), 385-387 enemies dropping power-ups, 541-543
Collider components, 272, 295-296 enemy attack/damage, 513-518
creating, 271-272 enemy GameObjects, 504-506
editing, 272, 277-278 enemy scripts, 506-509, 543-556
Mesh Collider component, 295 function delegate for firing, 525-531
878 GAMEOBJECTS

hero shield, 493-495 Games Education Programs, 215-217

hero ship, 491-493 gametesting. See playtesting
hero ship bounds, 495-498 Gamma, Erich
layers, 510-513 Design Patterns, 769-770, 815-817
power-ups, 531-538, 541-543 software design, 815
restarting games, 518-519 Factory design pattern, 816
shooting, 519-531 Singleton design pattern, 815-816
spawning enemies, 509-510 Strategy design pattern, 816-817
tags, 511-513 spawning enemies/enemy factories, 769-770
testing overlapping bounds, 500-504 Garfield, Richard
weapon definitions, 521-525 innovation and the design process, 97-98
Sphere Collider component, 295 RoboRally, 97-98
Transform component, 272, 294-295 Georgia Institute of Technology, interactive
gameplay as art (cultural aesthetics), 83 narrative example, 75
gameplay development (paper gizmos (Unity), 277
prototyping), 132 GM (Game Master) strategies, paper
control points, capturing, 137 prototyping, 137
counterattacks, 135 goals, indirectly guiding players by, 200
cover, 136 goals of design, 105-106, 124
health designer-centric goals, 106
health packs, 136 community, 107-108
starting health, 136 fame, 107
interception fire, 137 fortune, 107
movement systems, 134, 138 greater good, 108-109
objectives, 132 personal development/experience, 109
required equipment, 132 personal expression/communication, 108
setup, 133 player-centric goals, 106
visibility, 133-134, 136 attention and involvement, 118-120
weapons/firing, 134-135, 137-138 empowerment, 116-118
games, defining experiential understanding, 122-123
Bateman, Chris, 15 fiero, the concept of, 110
Burgun, Keith, 11, 14-15 flow, 113-115
evolution of definitions, 16-17 fun, 109-110
Fullerton, Tracy, 10, 13 interesting decisions, 120-122
importance of, 15-16 lusory attitude, 110-112
importance of definitions, 17-18 structured conflict, 115-116
IndieCade, 17 God of War, flow as a player-centric goal of
Meier, Sid, 10, 13 design, 115
Midgley, Mary, 15-16 gold phase (project development process), 103
nature of definitions, 16-17 Goldstone, Will, and Unity-related websites, 853
Pearce, Celia, 17 Grand Theft Auto, resource mechanics, 45
Roberts, Sam, 17 Grand Theft Auto V, player guidance, 199
Schell, Jesse, 11, 13-14 graphics (frames)
Suits, Bernard, 10-15 defining, 232
Wittgenstein, Ludwig, 15 flowcharts (GameObjects), 232
 HEART OF DARKNESS, THE, AS EXAMPLE OF INSCRIBED DRAMATICS 879

Grasshopper, The, 10-11 Guitar Hero, 200-201

lusory attitude as a player-centric goal of Journey, 201-202, 206
design, 110-111 Kya: Dark Legacy, 205
Suits, Bernard, 15 landmarks, 201-202
greater good, designing games for the, 108-109 light, 201-202
Greater Than comparison operator (>) in C# Minecraft, 200
coding, 306 NPC, 205-206
Greater Than or Equal To comparison operator physical interface, 200-201
(>=) in C# coding, 306-307 player avatars, 205
Green, Ryan, and That Dragon, Cancer as a Rock Band, 200-201
personal expression/communication as a goal similarities, 201
of game design, 108 texture, 204
Gregory and Tic-Tac-Toe, Kia, 65 trails, 201
Groundhog Day, experiential understanding as a Uncharted 3, 203
player-centric goal of design, 122-123 visual design, 201-204
group playtesting methods, 146-147 integration, 209
GUI (Graphical User Interfaces) quality of guidance, determining, 197-198
Apple Picker, 440-448 teaching new skills/concepts, 207-209
paper prototyping, 139 Guitar Hero, player guidance, 200-201
guides, fan-made game guides (cultural
technology), 84-85
guiding players, 210 H
direct guidance, 199
HAL Laboratories, Kirby and integrated actions
Assassin's Creed IV: Black Flag, 199
(meaningful play), 64-65
calls to action, 199
Half-Life
Grand Theft Auto V, 199
game mods and cultural mechanics, 81-82
instructions, 199
narrative premises, examples of, 49
Kya: Dark Legacy, 198
Halo
Legend of Zelda: Ocarina of Time, 199
inscribed dramatics, example of, 58
maps/guidance systems, 199
limited possibilities and interactive or linear
quality of guidance, determining, 198
narrative, 53-54
Skyrim, 198
prior art, researching (analysis phase of
Valkyrie Chronicles, 198
iterative design), 92
indirect guidance, 200
Red vs. Blue, machinima example, 83-84
arrows, 202-203
Hamlet on the Holodeck, interactive narrative
Assassin's Creed, 205
example, 75
audio design, 204-205
headaches, player considerations
brightness, 204
(environmental aesthetics), 74
camera, 203
health (avatar/character) in gameplay
color, 204
development (paper prototyping)
constraints, 200
health packs, 136
contrast, 204
starting health, 136
directionality, 204
hearing (Inscribed Layer aesthetics), 47
Disneyland, 202
Heart of Darkness, The, as example of inscribed
goals, 200
dramatics, 57-58
880 HEINSOO, ROB, ON XP (EXPERIENCE POINTS) AND CUMULATIVE OUTCOMES

Heinsoo, Rob, on XP (Experience Points) Hunicke and MDA framework, Robin, 20, 29
and cumulative outcomes (dynamic aesthetics-based design, 21-24
mechanics), 69 defining, 20-21
Hello World program, 263, 279 designer views of games, 21
arrays in, 344-347 player views of games, 21
C# scripts, creating, 266-271
debugging C# coding, 364
GameObjects I
creating, 271-272
ideation (brainstorming), 98
editing, 272
collection phase, 99
playing, 272-273
collision phase, 100-101
gizmos, 277
discussions, 101
lists in, 344-347
expansion phase, 98-99
naming projects, 266
rating phase, 101
prefabs, 273-277
if statements (C# coding), 307-310
scene views, changing, 277-278
Ilinx (vertigionous play)
standard project setup procedures, 264
Imaginary Games, 110
Helm, Richard
Jeux et Le Hommes, Le, and the four different
Design Patterns, 769-770, 815-817
kinds of play, 110
software design, 815
Imaginary Games, 15
Factory design pattern, 816
Ilinx (vertigionous play), 110
Singleton design pattern, 815-816
structured conflict as a player-centric goal of
Strategy design pattern, 816-817
design, 115-116
spawning enemies/enemy factories, 769-770
immediacy of objectives (Inscribed layer
Hierarchy pane (Unity), 251
mechanics), 41
Hitchhiker's Guide to the Galaxy, The, and
immediacy of sound (Inscribed Layer
autotelic empowerment as a player-centric
aesthetics), 47
goal of design, 117
immediate outcomes (dynamic mechanics), 69
Homo Ludens, magic circle concept and lusory
implementation phase (iterative design), 90-91,
attitude, 112
94-97
hooks (three-act dramatic narrative
importance of objectives (Inscribed layer
structure), 52
mechanics), 42
hours (estimated versus real) and burndown
iMUSE (Interactive MUsic Streaming Engine), 70
charts, 413
inciting incidents (three-act dramatic narrative
house rules (dynamic mechanics), 66-67
structure), 52
Hoye, Mike
increasing difficulty, Apple Picker, 448
Legend of Zelda: The Wind Waker, The, 83
Incredible Machine, The, 188
narrative game mods, 83
incremental innovation, 97
HRS (Horizontal Re-Sequencing), procedural
INDEX formula (Calc), weighted probabilities,
music, 70
174-175
Huizinga, Johan
indie games and the digital game industry, 214
Homo Ludens, 112
magic circle concept and lusory
attitude, 112
 INSPECTOR PANE (UNITY) 881

IndieCade Game Festival informal individual playtesting method, 146

games, defining, 17 information, conveying (Inscribed Layer
indie games and the digital game aesthetics), 48-49
industry, 214 inheritance in classes (C# coding), 387
scoping and the design process, 104 innovation and the design process, 97-98
indirectly guiding players, 200 Inscribed Layer (Layered Tetrad), 32, 37, 39, 59
arrows, 202-203 aesthetics, 46
Assassin's Creed, 205 defining, 33
audio design, 204-205 five aesthetic senses, 47-48
brightness, 204 goals of aesthetic design, 48-49
camera, 203 hearing, 47
color, 204 immediacy of sound (Inscribed Layer
constraints, 200 aesthetics), 47
contrast, 204 information, conveying, 48-49
directionality, 204 mood, conveying, 48
Disneyland, 202 smell, 48
goals, 200 touch, 47-48
Guitar Hero, 200-201 vision, 47
Journey, 201-202, 206 designer responsibilities, 36
Kya: Dark Legacy, 205 mechanics, 40
landmarks, 201-202 boundaries, 40, 44
light, 201-202 defining, 32
Minecraft, 200 objectives, 40-42
NPC, 205-206 player relationships, 40, 42-44
physical interface, 200-201 resources, 40, 45
player avatars, 205 rules, 40, 44
Rock Band, 200-201 spaces, 40, 45-46
similarities, 201 tables, 40, 46
texture, 204 narrative, 49
trails, 201 characters, 49
Uncharted 3, 203 components of, 49-50
visual design, 201-204 defining, 33
individual playtesting methods five-act dramatic structure, 50-51
formal method, 147-148 inscribed dramatics, purposes of, 57-58
labs, 148-149 interactive versus linear narrative, 53-57
running playtests, 149 linear versus interactive narrative, 53-57
informal method, 146 plots, 50
infinite loops (C# coding), 317-318 premises, 49
Influence: The Psychology of Persuasion, 4 settings, 49
Infocom three-act dramatic structure, 51-52
Hitchhiker's Guide to the Galaxy, The, and technology, 58
autotelic empowerment as a player-centric defining, 33
goal of design, 117 paper game technologies, 58-59
Planetfall, developing relationships through Inspector pane (Unity), 251
shared experience, 76 editing GameObjects, 272
GameObjects, components of, 294
882 INSTALLING

installing Internet's role in playtesting, 145-146, 150

Calc, 156-157 closed playtesting, 150
Unity, 241 limited playtesting, 150
instance variables (C# coding), 289 open playtesting, 150-151
instructions interpolation, 831
directly guiding players by, 199 interpolating values other than position,
simple instructions exercise (systems 834-835
thinking), 226-227 linear interpolation, 831
int variables (C# coding), 284 easing, 837-841
integration time-based linear interpolation, 831-832
integrated actions (meaningful play), Zeno's Dichotomy Paradox and linear
64-65, 121 interpolation, 833-834
teaching players by, 209 intersectional innovation, 97, 99
interactive narrative interviewing, finding a career in the digital
characters, 49 game industry, 219-220
components of, 49-50 investigators (playtesting), defining, 142
dynamic dramatics, 75 involvement and attention as player-centric
developing relationships through shared goals of design, 118-120
experience, 76 Is Equal To comparison operator (==), 304
interactive fiction and player experience, iterative design, 90
75-76 analysis phase, 90-91
five-act dramatic structure, 50-51 determining audience, 91
linear narrative versus, 53 determining fastest path to testing, 92
empathetic characters versus avatars, determining resources, 91-92
55-57 importance of repetition, 96-97
foreshadowing, 55 researching prior art, 92
limited possibilities, 53-54 design phase, 90
NPC development, 55 importance of listening, 92-94
pen-and-paper RPG, 55 importance of repetition, 96-97
plot versus free will, 53-55 implementation phase, 90-91, 94-97
side quests, 54 repetition, importance of, 96-97
plots, 50 testing phase, 91, 95-97
premises, 49
settings, 49
three-act dramatic structure, 51-52 J
interception fire, gameplay development (paper
jagged arrays (C# coding), 340-342
prototyping), 137
jagged lists (C# coding), 342-344
interest as a player-centric goal of design,
JavaScript, 238-239
118-120
Jenkins on transmedia, Henry, 86
interesting decisions as a player-centric goal of
Jeux et Le Hommes, Le, and the four different
design, 120-122
kinds of play, 110
interesting polling (playtesting), 152
interfaces (C# coding), 769-770, 782-785,
807-810
 LAYERED TETRAD 883

jobs in the digital game industry, 217 genres of puzzles, 187-188

following up, 218-219 goals of effective design
interviewing, 219-220 puzzles, defining, 186-187
networking, 217-218 reasons for playing puzzles, 189
salaries, 220 required modes of thought in solving,
Johansson, Frans 189-190
innovation and the design process, 97 story puzzles, 188
Medici Effect, The, 97 strategy puzzles, 188
Johnson, Ralph Sudoku, 188
Design Patterns, 769-770, 815-817 Kirby, integrated actions (meaningful play),
software design, 815 64-65
Factory design pattern, 816 Klei Entertainment, Mark of the Ninja and intent
Singleton design pattern, 815-816 versus execution, 187
Strategy design pattern, 816-817 Kya: Dark Legacy and player guidance, 198, 205
spawning enemies/enemy factories, 769-770
joining game projects in development, 221
Journey, 41 L
player guidance, 201-202, 206
lab setups for formal individual playtesting,
tissue playtesters, 144-145
148-149
jump statements in loops (C# coding), 322-324
labeling rows (Calc spreadsheets), 162-163
justification (inscribed dynamics), 57-58
landmarks
indirectly guiding players by, 201-202
space and landmarks (Inscribed Layer
K mechanics), 45-46
Kaboom!, game analysis (systems thinking), 229 languages (computer) and systems
GameObject action lists, 231-232 thinking, 227
GameObject flowcharts, 232-234 Larson, Josh, and That Dragon, Cancer as a
GameObjects, 230-231 personal expression/communication as a goal
gameplay, 230 of game design, 108
Kaplan, Larry, on Kaboom! game analysis Last of Us, The, and screenresolution, 73
(systems thinking), 229-234 law and cultural impact of games, 86-87
Killer player type (clubs), 67 layer masks and bitwise Boolean operators (C#
Kim, Scott, and puzzle design coding), 801-802
action puzzles, 188 Layered Tetrad
Art of Puzzle Design, The, 186 Cultural Layer, 34-35, 37-38, 79, 87
eight steps of puzzle design, 191-192 aesthetics, 35, 82-83
genres of puzzles, 187-188 cultural impact of games, 86-87
goals of effective design, 192-193 defining, 80-81
reasons for playing puzzles, 189 designer responsibilities, 37
required modes of thought in solving, 189 law and cultural impact of games, 86-87
bridge puzzles, 188 mechanics, 35, 81-82
chess puzzles, 188 narrative, 36, 83-84
construction puzzles, 188 technology, 36, 84-85
crossword puzzles, 188 transmedia, 85-86
eight steps of puzzle design, 191-192
884 LAYERED TETRAD

designer responsibilities Legend of Zelda: Twilight Princess, The, andtouch

Cultural Layer, 37 as an Inscribed Layer aesthetic, 48
Dynamic Layer, 36-37 LeMarchand, Richard
Inscribed Layer, 36 attention and involvement as player-centric
Dynamic Layer, 33-34, 37, 61, 77 goals of design, 118-120
aesthetics, 34 engaging play as a player-centric goal of
designer responsibilities, 36-37 game design, 110
dramatics, 75-77 Less Than comparison operator (<) in C#
emergence, 63-64 coding, 306
mechanics, 34, 64-69 Less Than or Equal To comparison operator (<=)
narrative, 34 in C# coding, 306-307
player's role in game design, 62-63 Level Up! The Guide to Great Video Game Design,
technology, 34, 77 64, 202
Inscribed Layer, 32, 37, 39, 46-49, 59 levels (custom) and cultural mechanics, 82
aesthetics, 33 licensing Unity, 241-242
boundaries, 40, 44 light, indirectly guiding players by, 201-202
designer responsibilities, 36 limited playtesting (beta tests), 150
mechanics, 32, 40-46 limited possibilities and interactive
narrative, 33 narrative, 53-54
objectives, 40-42 Linderman, Frank Bird,
player relationships, 40, 42-44 Chief Plenty-Coups and coup-counting as a
resources, 40, 45 game, 115-116
rules, 40, 44 structured conflict as a player-centric goal of
spaces, 40, 45-46 design, 115-116
tables, 40, 46 linear extrapolation, 835-837
technology, 33 linear interpolation, 831
introduction to, 31-32 easing, 837-841
Lazzaro, Nicole, and the concept of fiero time-based linear interpolation, 831-832
(player-centric game design), 110 Zeno's Dichotomy Paradox and linear
Learn section (Unity website), 852 interpolation, 833-834
LeBlanc, Mark, and MDA framework, 20, 29 linear narrative
aesthetics-based design, 21-24 characters, 49
defining, 20-21 components of, 49-50
designer views of games, 21 five-act dramatic structure, 50-51
player views of games, 21 interactive narrative versus linear
Legend of Zelda: Ocarina of Time, The, and player narrative, 53
guidance, 199 empathetic characters versus avatars,
Legend of Zelda, The 55-57
resource mechanics, 45 foreshadowing, 55
silent protagonists (empathetic characters limited possibilities, 53-54
versus avatars), 56 NPC development, 55
Legend of Zelda: The Wind Waker, The pen-and-paper RPG, 55
inscribed dramatics, example of, 57-58 plot versus free will, 53-55
narrative game mods, 83 side quests, 54
 LUSORY ATTITUDE 885

plots, 50 X-Wing
premises, 49 information, conveying (Inscribed Layer
settings, 49 aesthetics), 48-49
three-act dramatic structure, 51-52 music in, 70
LineRenderer (Unity), ground spells in Omega ludology, 19. See also Layered Tetrad
Mage, 756-761 Elemental Tetrad framework, 20, 27-29
LINQ (Language Integrated Query) and C# aesthetics, 27-28
coding, 640-641 mechanics, 27
Lionhead Studios, Fable and the limited story's role in, 28
possibilities of interactive or linear narrative, technology's role in, 28
53-54 FDD framework, 20, 24, 29
listening, importance of during design phase boundaries, 25
(iterative design), 92-94 characters, 26
lists (C# coding), 328-331, 344 Dramatic elements, 24, 25-26
arrays versus lists, 344 Dynamic elements, 24, 26-27
converting arrays to lists, 336-337 Emergence, 26-27
converting lists to arrays, 331 Emergent Narrative, 27
jagged lists, 342-344 Formal elements, 24-25
methods, 331 objectives, 25
properties, 331 outcomes, 25
zero indexed lists, 331 player interaction patterns, 24
long-term objectives, space and (Inscribed playtesting, 27
Layer mechanics), 46 premises, 25-26
loops (C# coding), 315, 325 procedures, 25
do.while loops, 316, 319-320 resources, 25
for loops, 316, 320-322, 342 rules, 25
foreach loops, 316, 322 stories, 26
empty array elements and foreach loops, MDA framework, 20, 29
335 aesthetics-based design, 21-24
infinite loops, dangers of, 317-318 defining, 20-21
jump statements in loops, 322-324 designer views of games, 21
modulus operator (%), 324 player views of games, 21
project setup, 300-301 Ludwig, Manfred
types of, 316 optimal strategy, determining (dynamic
while loops, 316-319 mechanics), 65-66
Lucas, George Up The River, 65-66
scoping and the design process, 104 Lunch Money, house rules (dynamic
Star Wars: A New Hope as an example of mechanics), 67
three-act dramatic narrative structure, lusory attitude, 13-14, 110-112
51-52
LucasArts
iMUSE (Interactive MUsic Streaming
Engine), 70
886 MACHINIMA

M spreadsheets, creating, 158

summing dice role results, 163
machinima, 83-84 Unity example, 825-829
magic circle concept and lusory attitude, 112 permutations, 175-176
Magic:The Gathering, illegal cards and positive/negative feedback, 176-177
emergence (Dynamic Layer), 64 randomization
Mainichi custom card decks, 172
experiential understanding as a dice, 170
player-centric goal of design, 122-123 playing cards, 171-173
personal expression/communication as a shuffling decks, 172-173
goal of game design, 108 spinners, 170
Majestic, 17, 44 Ten Rules of Probability Every Game Designer
Mangle of Play, The, and the cultural aspects of Should Know, 165-169
game development, 80-81 weapons, balancing, 177-178
Manifesto for Agile Software Development, average damage, 179-180
406-407 Chapter 9 prototype example, 182-183
maps/guidance systems, directly guiding duplicating weapon data, 180-181
players by, 199 overall damage, showing, 181
Marathon, researching prior art (analysis phase percent chance for each bullet,
of iterative design), 92 determining, 178
Mario Kart and game balance, 177 rebalancing weapons, 177-178
Mark of the Ninja, intent versus execution, 187 weighted distributions, 173-175
Mass Effect weighted probabilities, 174-175
multiple dialogue choices (empathetic math concepts
characters versus avatars), 57 Bézier curves, 841-845
player interaction patterns, 43 dice probability, Unity example, 825-829
resolution (screen), 73 dot product, 829-830
Mateas, Michael extrapolation (linear), 835-837
autotelic empowerment as a player-centric interpolation
goal of design, 117 easing linear interpolation, 837-841
Façade, 117 interpolating values other than position,
math and game balance, 155, 183 834-835
balance, defining, 156 linear interpolation, 831
Calc, installing, 156-157 time-based linear interpolation, 831-832
dice probability, determining with Calc, Zeno's Dichotomy Paradox and linear
157-158 interpolation, 833-834
adjusting column widths, 160 recursive Bézier curves, 844-845
charting results, 164 sine/cosine, 822-825
counting die roll sums, 163-164 mathf variables (C# coding), 292
creating Die A row, 160-161 MDA framework (ludology), 20, 29
creating Die B row, 161-162 aesthetics-based design, 21-24
creating probability distribution charts, 164 defining, 20-21
creating rows, 159 designer views of games, 21
entering data in cells, 158-159 player views of games, 21
labeling rows, 162-163
 MISSION DEMOLITION 887

meaningful play Meier, Sid

dynamic mechanics, 64-65 Civilization, tables, 40-41
dynamic procedures C.P.U. Bach, music in, 71
discernable actions, 121 games, defining, 13
integrated actions, 121 interesting decisions as a player-centric goal
interesting decisions as a player-centric of design, 121
goal of design, 120-121 melee, pronunciation of, 42
mechanics Meretzky, Steven
attention and involvement as a developing relationships through shared
player-centric goal of design, 120 experience, 76
Cultural Layer (Layered Tetrad), 81 Planetfall, 76
custom game levels, 82 Mesh Collider component (GameObjects), 295
defining, 35 Mesh Filter component (GameObjects), 272, 295
game mods, 81-82 Mesh Renderer component (GameObjects), 272
Dynamic Layer (Layered Tetrad) Microsoft controllers
defining, 34, 64 axis mapping, 848-849
defining strategies, 65 button mapping, 848-849
designing for strategies, 66 Midgley, Mary
determining optimal strategy, 65-66 Game Game, The, 15-16
determining player intent, 67-68 games, defining, 15-16
emergence (unexpected), 63-64 migraines, player considerations (environmental
house rules, 66-67 aesthetics), 74
meaningful play, 64-65 Miles, Rob, and CSharp Yellow Book, 854
outcomes, 69 Mimicry, Le Jeux et Le Hommes and the four
player types, 67-68 different kinds of play, 110
procedures, 64 Minecraft
Elemental Tetrad framework, 27 autotelic empowerment as a player-centric
Inscribed Layer (Layered Tetrad), 40 goal of design, 117
boundaries, 40, 44 player guidance, 200
defining, 32 player-built external tools as example of
objectives, 40-42 cultural technology, 84
player relationships, 40, 42-44 procedural environments, 73
resources, 40, 45 Minority Media, Papa y Yo as a personal
rules, 40, 44 expression/communication as a goal of game
spaces, 40, 45-46 design, 108
tables, 40, 46 Mission Demolition, 449, 485
reinforcing via inscribed dramatics, 58 art assets, 451-456
spoilage mechanic (Farmville), 112 C# coding, 456
Medici Effect, The, innovation and the design adding levels, 479-485
process, 97 castles, 471-473
medium-term objectives and space (Inscribed clouds, 467-471
Layer mechanics), 46 follow cameras, 462-466
meetings and Scrum software development game logic, 479-485
methodologies, 409 hitting the goal, 478-479
888 MISSION DEMOLITION

instantiating projectiles, 458-462 resource mechanics, 45

projectile trails, 474-478 roles of players (player relationships),
returning shots, 473-474 defining, 43
slingshots, 456-462 mood, conveying (Inscribed Layer
vection/sense of speed, 466-471 aesthetics), 48
camera setup, 451-453 motivation (inscribed dynamics), 57-58
concept of, 450-451 mouse interaction, programming in Omega
directional light GameObject, 451 Mage, 737-741
ground GameObject, 451 movement, 741-747
project setup, 450 moving when dragging, 746-747
projectile component, 455-456 tap indicators, 743-745
sequence of events during play, 450-451 movement systems, developing, 127-128, 138
slingshot GameObject, 453-455 MUD (Multi-User Dungeon) games, 67-68
mission types (paper prototyping), determining, multidimensional arrays (C# coding), 337-340
131-133 multilateral competition (player interaction
MMORPG (Massively Multiplayer Online patterns), 43
Role-Playing Game), player interaction multiplayer games
patterns, 43 puzzles and, 186
MOD formula (Calc), 160-161 roles of players (player relationships),
model/animation resources, 854-855 defining, 44
Modern Warfare as example of inscribed multiple individual players versus game (player
dramatics, 58 interaction patterns), 43
modifying games (cultural mechanics), Murray, Janet
81-83 developing relationships through shared
modulus operator (%) in C# coding, 324 experience, 76
Mojang and Minecraft Hamlet on the Holodeck, 75
autotelic empowerment as a player-centric interactive narrative, 75
goal of design, 117 Planetfall, 76
player guidance, 200 music, 70
player-built external tools as example of C.P.U. Bach, music in, 71
cultural technology, 84 Elite Beat Agents, 71
procedural environments, 73 Flower, music in, 71
money as a goal of game design, 107 Frequency, 70-71
MonoDevelop editor HRS (Horizontal Re-Sequencing), 70
creating C# scripts, 266-271 immediacy of sound (Inscribed Layer
debugging C# coding aesthetics), 47
attaching debugger to Unity, 372-374 iMUSE (Interactive MUsic Streaming
stepping through code, 369-371, 373-377 Engine), 70
variables, 375-376 Osu Tatake Ouendan!, 71
Monopoly PaRappa the Rapper, 70-71
conflicting objectives (Inscribed layer PCO (Procedural Composition), procedural
mechanics), 42 music, 71
immediate outcomes (dynamic mechanics), VRO (Vertical Re-Orchestration), procedural
example of, 69 music, 70-71
Myst, 188
 OKAMI 889

N Uncharted 2: Drake's Deception, machinima

example, 84
Nakamura, Jeanne Uncharted 3
autotelic empowerment as a player-centric particle systems (procedural visual art),
goal of design, 116-117 71-72
Concept of Flow, 113-114, 116-117 player guidance, 203
flow as a player-centric goal of design, navigating Unity, 251
113-114 negative/positive feedback, game balance,
naming 176-177
C# naming conventions, 286-287 networking, finding a career in the digital game
projects in Unity, 266 industry, 217-218
narrative Neverwinter Nights, narrative game mods, 83
attention and involvement as player-centric Nintendo, Mario Kart and game balance, 177
goals of design, 120 noisy environments (environmental
Cultural Layer (Layered Tetrad), 83 aesthetics), 74
defining, 36 Not Equal To comparison operator (!=) in C#
fan fiction as cultural narrative, 83 coding, 306
game mods as cultural narrative, 83 NOT operator (!) in C# coding, 300
machinima, 83-84 novel decisions as part of player-centric
Dynamic Layer (Layered Tetrad), defining, 34 design, 121
emergent narrative, 76-77 NPC (Non-Player Characters)
Inscribed Layer (Layered Tetrad), 49 development of (interactive narratives), 55
characters, 49 indirectly guiding players by, 205-206
components of, 49-50
defining, 33
five-act dramatic structure, 50-51
inscribed dramatics, purposes of, 57-58
O
interactive versus linear narrative, 53-57 objectives
linear versus interactive narrative, 53-57 FDD framework, 25
plots, 50 gameplay development (paper prototyping),
premises, 49 132
settings, 49 Inscribed Layer (Layered Tetrad), 40-41
three-act dramatic structure, 51-52 conflicting objectives, 42
interactive narrative (dynamic dramatics), 75 immediacy of objectives, 41
developing relationships through shared importance of objectives, 42
experience, 76 long-term objectives and space, 46
interactive fiction and player experience, medium-term objectives and space, 46
75-76 short-term objectives and space, 46
Naughty Dog objects, C# as OOC (Object-Oriented Coding),
Uncharted 258-259
inscribed dramatics, example of, 58 Okami
limited possibilities and interactive or empathetic characters versus avatars, 56
linear narrative, 53-54 touch as an Inscribed Layer aesthetic, 48
role fulfillment (empathetic characters
versus avatars), 56
890 OMEGA MAGE

Omega Mage OOC (Object-Oriented Coding), C# as, 258-259

changing rooms, 764-768 OOP (Object-Oriented Programming) in C#. See
creating the game environment, 730-735 also classes (C# coding), 391, 403
customizing setup, 789 Boids project, 394
damaging players, 777-782 building simple models, 394-396
enemies, 768-770 project setup, 394
damaging, 772-777 scripts, 397-403
enemy factories, 785-789 defining through metaphors, 392-393
EnemyBug GameObjects, 770-780 open playtesting (beta tests), 150-151
EnemySpiker GameObjects, 780-782 OpenOffice Calc. See Calc
interfaces, 782-785 OR operator (||) in C# coding, 300
example of play, 728-729 Origin Systems, Ultima IV, actions (players),
fire ground spell, 754-762 tracking and reacting to (empathetic
fire spell, 761-762 characters versus avatars), 57
fire-and-forget spells, 762-764 orthographic cameras, 425-426
ground spell, 756-761 OS X
importing Unity asset packages, 729 force-quitting applications, 317-318, 371
inventories right-clicking and, 265, 849-850
camera setup, 748-749 Unity, new project setup procedures,
creating, 747-748 794-796
selecting elements, 749-754 Osu Tatake Ouendan!
Mage GameObject (player character), fulfilling play as a player-centric goal of
735-737 game design, 110
mouse interaction, 737-741 music in, 71
moving when dragging, 746-747 outcomes
tap indicators, 743-745 Dynamic Layer (Layered Tetrad), 69
movement, 741-747 FDD framework, 25
project setup, 729 overall damage, showing (weapons and game
online playtesting, 150 balance), 181
closed playtesting, 150 overscoping (design process), 103-104
limited playtesting, 150
open playtesting, 150-151
online resources P
animation/model resources, 854-855
Pajitnov, Alexi
art assets, 854
Art of Puzzle Design, The, 186
audio assets, 854
eight steps of puzzle design, 191-192
C# resources, 853-854
genres of puzzles, 187-188
educational software discounts, 855
goals of effective design, 192-193
font-related resources, 855
reasons for playing puzzles, 189
game developer salary surveys, 220
required modes of thought in solving, 189
model/animation resources, 854-855
Tetris, 186
Unity
panes (Unity), 251
tutorials, 852
Console pane, 251
Unity-related websites, 852-853
Game pane, 251
Hierarchy pane, 251
 PHYSICS GAMES 891

Inspector pane, 251 randomization, 59

layouts, configuring, 246-251 custom card decks, 172
Project pane, 251 dice, 170
Scene pane, 251 playing cards, 171-173
Papa Sangre, sound as an Inscribed Layer shuffling decks, 172-173
aesthetic, 47 spinners, 170
Papa y Yo, personal expression/communication state tracking, 59
as a goal of game design, 108 tips for running good campaigns, 846-847
paper games performative empowerment as a player-centric
Dungeons & Dragons, 846-847 goal of design, 118
FATE system, 846-847 permutations, 175-176
progression, 59 permutations without repeating
randomization, 59 elements, 176
custom card decks, 172 repeating elements in, 176
dice, 170 personal development/experience, designing
playing cards, 171-173 games for, 109
shuffling decks, 172-173 personal expression/communication as a goal
spinners, 170 of game design, 108
state tracking, 59 perspective cameras, 425-426
tips for running good campaigns, 846-847 Philosophical Investigations, 15
paper prototyping, 125, 140 physical interface, indirectly guiding players
benefits of, 126 by, 200-201
best uses for, 138-139 physics games
example of, 129 Mission Demolition, 449, 485
determining mission types, 131-133 adding levels, 479-485
gameplay development, 132-137 art assets, 451-456
GM strategies, 137 C# coding, 456-485
initial concept development, 129-130 camera setup, 451-453
playtesting, 138 castles, 471-473
prototype construction, 131-133 clouds, 467-471
movement systems, 127-128, 134, 138 concept of, 450-451
poor uses for, 139 directional light GameObject, 451
tools for, 127-129 follow cameras, 462-466
PaRappa the Rapper, music in, 70-71 game logic, 479-485
particle systems (procedural visual art), 71-72 ground GameObject, 451
Passage, 11-12 hitting the goal, 478-479
Pauling, Linus, brainstorming (ideation), 98 instantiating projectiles, 458-462
PCO (Procedural Composition), procedural project setup, 450
music, 71 projectile component, 455-456
Pearce, Celia, and game definitions, 17 projectile trails, 474-478
pen-and-paper RPG returning shots, 473-474
Dungeons & Dragons, 846-847 sequence of events during play, 450-451
FATE system, 846-847 slingshot GameObject, 453-455
progression, 59 slingshots, 456-462
vection/sense of speed, 466-471
puzzles in, 194
892 PLANETFALL

Planetfall experiential understanding, 122-123

developing relationships through shared fiero, the concept of, 110
experience, 76 flow, 113-115
interactive narrative example, 75 fun, 109-110
player interaction patterns, 24 interesting decisions, 120-122
Inscribed Layer (Layered Tetrad), 43 lusory attitude, 110-112
cooperative play, 43 structured conflict, 115-116
multilateral competition, 43 relationships at the Inscribed Layer (Layered
multiple individual players versus game, 43 Tetrad), 40, 42
player versus player, 43 roles of, 43-44, 62-63
single player versus game, 43 teaching new skills/concepts
team competition, 43 integration, 209
unilateral competition, 43 sequencing, 207-209
Mass Effect, 43 types of, Bartle's four players who suit MUDs,
players 67-68
avatars, indirectly guiding players by, 205 playing cards/card decks
Bartle's four players who suit MUDs, 67-68 Bartok, 621-622, 655
community as a goal of game design, backgrounds, 622-623
107-108, 120 build settings, 623-624
environmental aesthetics (Dynamic card animation, 623
Layer), 74 creating cards, 624-629
colorblindness, 74 fanning the hand, 638-640
epilepsy, 74 game logic, 653-655
headaches, 74 layouts, 629-638
migraines, 74 LINQ (Language Integrated Query) and C#
volume control, 74 coding, 640-641
external tools (player-built) and cultural managing the initial deal, 642-643
technology, 84-85 managing turns, 646-653
gameplay development (paper prototyping), moving cards, 641-642
132-137 rules of the game, 622
guiding, 197-198, 210 sorting order (2D-depth), 643-646
direct guidance, 198-199 custom card decks, 172
indirect guidance, 200-206 Poker
teaching new skills/concepts, 207-209 game balance and, 176-177
intent, determining (dynamic mechanics), Red Dead Redemption rule mechanics, 44
67-68 art assets, 614-615
interaction patterns (FDD framework), 24, 43 backgrounds, 614-615
movement systems and gameplay beginning/end of round announcements,
development (paper prototyping), 615-616
134, 138 chain scoring, 605-607
player versus player (player interaction clickable card functionality, 597-600
patterns), 43 creating cards from sprites, 566-581
player-centric goals of design, 106 displaying scores to players, 607-614
attention and involvement, 118-120 draw and discard actions, 597-604
empowerment, 116-118 earning points, 604-605
 POST-RELEASE PHASE (PROJECT DEVELOPMENT PROCESS) 893

example of play, 584-585 online playtesting, 150-151

game logic, 597-604 scripts, 147
giving player feedback on scores, 616-619 paper prototyping, 138
gold cards, 620 playtesters
importing images as sprites, 564-566 acquaintances as playtesters, 145
importing Unity asset packages, 562 circle of playtesters, 143-146
matching drawn cards, 600-604 defining, 142
mine tableau layout, 585-592 friends as, 144
mobile device build settings, 562-563, 620 Internet as, 145-146
positioning cards on tableau, 592-594 tissue playtesters, 144-145
project setup, 562 ways to be a great playtester, 142-143
rules of the game, 583-584 you as, 143-144
scoring, 604-619 QA (Quality Assurance) testing, 152-153
setting up sorting layers on tableau, questions, asking, 7
594-597 rounds, comparing, 9
shuffling cards, 581-583 rules, modifying, 8
Prospector Solitaire, 561 usability testing, 152
randomization, 171-173 plots
riffle shuffling, 7 first plot point (three-act dramatic narrative
shuffling, 7, 172-173 structure), 52
Vectorized Playing Cards 1.3 free will versus plot (interactive versus linear
Bartok, 622 narratives), 53-55
Prospector Solitaire, 562 Inscribed Layer (Layered Tetrad), 50
playtesting, 141, 153 second plot point (three-act dramatic
ADL (Automated Data Logging), 151 narrative structure), 52
analyzing game play, Bartok, 7 Pogo.com, Crazy Cakes playtesting and ADL
AT (Automated Testing), 153 (Automated Data Logging), 151
Bartok, 6-10 point-and-click adventure games, loss of
beta tests popularity, 117
closed playtesting, 150 points, adding in Apple Picker, 441-442
limited playtesting, 150 Pokemon
open playtesting, 150-151 epilepsy, 74
data tables, Inscribed Layer mechanics transmedia example, 85
(Layered Tetrad), 46 Poker
Dynamic elements (FDD framework), 27 game balance and, 176-177
feel, designing for, 9-10 Red Dead Redemption rule mechanics, 44
flukes, 8 polling (interest) and playtesting, 152
focus testing, 152 pop-ups, directly guiding players by, 199
importance of, 142 position puzzles/sliding blocks in action
interesting polling, 152 games, 193
investigators (playtesting), defining, 142 positive/negative feedback, game balance,
methods of testing, 146 176-177
formal group testing, 146-147 possible outcomes of probability, 166
formal individual testing, 147-149 post-release phase (project development
informal individual testing, 146 process), 103
894 POWER-UPS, BUILDING IN SPACE SHMUP

power-ups, building in Space SHMUP, 531-538, range of probabilities, 166

541-543 sought outcomes, 166
practical probability versus theoretical Ten Rules of Probability Every Game Designer
probability, 169 Should Know, 165-169
prefabs (Unity), 273-277 theoretical probability versus practical
premises probability, 169
FDD framework, 25 weighted probabilities, 174-175
Inscribed Layer (Layered Tetrad) probability tables, Inscribed Layer mechanics
defining, 49 (Layered Tetrad), 46
examples of, 49 procedural aesthetics (Dynamic Layer), 70
preproduction phase (project development procedural animation, 72
process), 102 procedural environments, 73
Prince of Persia, limited possibilities and procedural music, 70
interactive or linear narrative, 53-54 HRS (Horizontal Re-Sequencing), 70
Prince of Persia: The Sands of Time, limited PCO (Procedural Composition), procedural
possibilities and interactive or linear music, 71
narrative, 53-54 VRO (Vertical Re-Orchestration), procedural
prior art, researching (analysis phase of iterative music, 70-71
design), 92 procedural visual art, 71-72
prioritizing tasks in burndown charts, 414-415 procedural music, 70
probability procedures
adding probabilities, 166 Dynamic Layer (Layered Tetrad), 64
decimals, 165-166 FDD framework, 25
dice probability, determining with Calc, product backlogs/feature lists (Scrum software
157-158 development methodologies), 408
adjusting column widths, 160 production phase (project development
charting results, 164 process), 102-103
counting die roll sums, 163-164 Professor Layton, Myst, 188
creating Die A row, 160-161 Profiler (Unity), 663-665
creating Die B row, 161-162 programming. See also systems thinking
creating probability distribution charts, 164 C#, 253, 262
creating rows, 159 compiled language, C# as, 254-256
creating spreadsheets, 158 creating scripts, 266-271
entering data in cells, 158-159 features of (overview), 254
labeling rows, 162-163 functions, 257-258
summing dice role results, 163 managed code, C# as, 256
Unity example, 825-829 OOC (Object-Oriented Coding), C# as,
enumeration, 166 258-259
fractions, 165-166 reasons for choosing, 238-239
multiplying probabilities, 166-167 runtime speed, 239
one minus the probability, 167-168 strongly typed language, C# as, 256-257
possible outcomes, 166 syntax of, 259-260
practical probability versus theoretical tips for learning, 239-241
probability, 169 variables, 256-257
 PROJECTS 895

Hello World program, 263, 279 example of, 410-412

creating C# scripts, 266-271 prioritizing tasks, 414-415
creating GameObjects, 271-272 C#, Boids project (OOP in C# coding),
creating projects in Unity, 264-266 394-403
editing GameObjects, 272, 277-278 classes (C# coding)
gizmos, 277 Enemy Class sample project, 381-384,
naming projects, 266 387-388
playing, 272-273 inheritance, 387-389
prefabs, 273-277 instances as GameObject components,
standard project setup procedures, 264 385-387
JavaScript, 238, 239 properties, 384-385
naming projects, 266 subclasses, 388-389
progression superclasses, 388-389
inscribed dramatics, 58 collections (C# coding), 328
paper game technologies, 59 arrays, 333-337
progression tables, Inscribed Layer mechanics Hello World program, 344-347
(Layered Tetrad), 46 jagged arrays, 340-342
project development process, 102 jagged lists, 342-344
alpha phase, 103 lists, 328-333
beta phase, 103 multidimensional arrays, 337-340
gold phase, 103 debugging C# coding, 363-364
post-release phase, 103 attaching debugger to Unity, 372-374
preproduction phase, 102 attaching/removing scripts, 366-367
production phase, 102-103 compile-time bugs, 364-366
Project pane (Unity), 251, 264-266 runtime errors, 367-369
Project Wizard (Unity), new project setup stepping through code, 369-371, 373-377
procedures, 794-796 variables, 375-376
projects development process
Agile software development methodologies, Agile software development
405-407, 416 methodologies, 405-407, 416
Apple Picker. See Apple Picker burndown charts, 409-416
arrays (C# coding), 328, 333-337 Manifesto for Agile Software Development,
Hello World program, 344-347 406-407
jagged arrays, 340-342 Scrum software development
multidimensional arrays, 337-340 methodologies, 407-409, 416
Bartok. See Bartok Enemy Class sample project
Boids project (OOP in C# coding), 394 class inheritance, 387-388
building simple models, 394-396 project setup, 381-384
project setup, 394 functions (C# coding), 349-350
scripts, 397-403 arguments and parameters, 353-354
burndown charts, 409 defining, 350-353
assigning tasks, 414-415 naming, 356
BDV (Burndown Velocity), 414-416 optional parameters, 359
creating, 416 overloading, 358
estimated hours versus real hours, 413
896 PROJECTS

params keyword, 359-361 beginning/end of round announcements,

reasons for using, 356-357 615-616
recursive functions, 361-362 clickable card functionality, 597-600
returning values, 354-356 draw and discard actions, 597-604
void, returning, 355-356 example of play, 584-585
Hello World program. See Hello World game logic, 597-604
program gold cards, 620
joining game projects in development, 221 importing Unity asset packages, 562
lists (C# coding), 328-333 matching drawn cards, 600-604
Hello World program, 344-347 mine tableau layout, 585-592
jagged lists, 342-344 positioning cards on tableau, 592-594
loops (C# coding) setting up sorting layers, 594-597
do.while loops, 319-320 mobile device build settings, 562-563, 620
foreach loops, 322 project setup, 562
jump statements in loops, 322-324 rules of the game, 583-584
for loops, 320-322 scoring
modulus operator (%), 324 chain scoring, 605-607
project setup, 300-301 displaying scores to players, 607-614
while loops, 316-319 earning points, 604-605
Mission Demolition. See Mission Demolition giving player feedback on scores, 616-619
naming, 266 shuffling cards, 581-583
Omega Mage. See Omega Mage sprites
OOP (Object-Oriented Programming), Boids creating cards from sprites, 566-581
project (OOP in C# coding), 394-403 importing images as sprites, 564-566
Prospector Solitaire. See Prospector Solitaire protagonists (player roles), 43, 56
QuickSnap. See QuickSnap prototypes (digital)
Scrum software development Apple Picker. See Apple Picker
methodologies, 407, 416 Bartok. See Bartok
meetings, 409 Game Feel: A Game Designer's Guide to Virtual
product backlogs/feature lists, 408 Sensation, 420
releases/sprints, 408 Mission Demolition. See Mission Demolition
teams, 408 Omega Mage. See Omega Mage
setup procedures, 264, 793, 796 Prospector Solitaire. See Prospector Solitaire
attaching C# scripts to scene Main Camera, purpose of, 420
797-798 QuickSnap. See Quick Snap
creating C# scripts, 797 Space SHMUP. See Space SHMUP
new projects, 794-796 Word Game. See Word Game
saving scenes, 796-797 prototypes (paper), 125, 140
Space SHMUP. See Space SHMUP benefits of, 126
starting, 221-222 best uses for, 138-139
Word Game. See Word Game example of, 129
Projects folder (Unity), viewing contents of, 265 gameplay development, 132-137
Prospector Solitaire, 561 GM strategies, 137
art assets, 614-615 initial concept development, 129-130
backgrounds, 614-615
 QUICKSNAP 897

mission types, determining, 131-133 project setup, 696

playtesting, 138 quality settings, 701-702
prototype construction, 131-133 recording player progress, 721-723
movement systems, 127-128, 134, 138 replacing shots, 715-716
poor uses for, 139 setting up, 706-707
tools for, 127-129 storing shots, 707-712
puzzles and puzzle design, 185, 195 reasons for playing puzzles, 189
action games, sliding blocks/position required modes of thought in solving,
puzzles, 193 189-190
action puzzles, 188 stealth puzzles, 194
Art of Puzzle Design, The, 186 story puzzles, 188
eight steps of puzzle design, 191-192 strategy puzzles, 188
genres of puzzles, 187-188 Sudoku, 188
goals of effective design, 192-193 traversal puzzles, 194
reasons for playing puzzles, 189
required modes of thought in solving, 189
boss fights, 195 Q
bridge puzzles, 188
QA (Quality Assurance) testing, 152-153
chain reaction puzzles, 194
Quake, machinima example, 84
chess puzzles, 188
Quake 2, game mods and cultural mechanics, 81
construction puzzles, 188
quaternion variables (C# coding), 291-292
crossword puzzles, 188
quest outcomes (dynamic mechanics), 69
defining, 186-187
questions, asking (game play analysis), Bartok, 7
eight steps of puzzle design, 191-192
QuickSnap, 695
genres of puzzles, 187-188
aspect ratios, 697
goals of effective design, 191-192
build settings, 696
Kim, Scott, 186-193
camera setup, 702-705
multiplayer games, 186
customizing setup, 725-726
physics puzzles, 194
debugging, 713-714
QuickSnap, 695
first-person controllers, 697-698
adding sound/visual effects to shots,
GUI elements, 703-705
723-725
importing Unity asset packages, 696-697
aspect ratios, 697
layers, 703-705
build settings, 696
lightmapping, 698-701
camera setup, 702-705
maximizing target window, 716-717
comparing shots, 717-721
project setup, 696
customizing setup, 725-726
quality settings, 701-702
debugging, 713-714
recording/displaying player progress,
deleting shots, 714-715
721-723
displaying player progress, 721-723
setting up, 706-707
first-person controllers, 697-698
shots
GUI elements, 703-705
adding sound/visual effects, 723-725
importing Unity asset packages, 696-697
comparing, 717-721
layers, 703-705
deleting, 714-715
lightmapping, 698-701
replacing, 715-716
maximizing target window, 716-717
898 RACE CONDITIONS (C# CODING)

R resolution (screen), environmental aesthetics

(Dynamic Layer), 73
race conditions (C# coding), 812-814 resources
RAND formula (Calc), weighted probabilities, animation/model resources, 854-855
174-175 art assets, 854
randomization audio assets, 854
dice, 170 C# resources
paper game technologies, 59 C# 4.0 Pocket Reference, 3rd Edition, 854
playing cards, 171-172 CSharp Yellow Book, 854
custom card decks, 172 online resources, 853-854
shuffling decks, 172-173 search tips, 854
spinners, 170 determining (analysis phase of iterative
rate of fire (weapons), gameplay development design), 91-92
(paper prototyping), 134-135, 137-138 educational software discounts, 855
rating phase (brainstorming/ideation), 101 FDD framework, 25
Ravensburger and Up The River font-related resources, 855
inscribed dramatics, example of, 58 Inscribed Layer (Layered Tetrad), 40, 45
optimal strategy, determining (dynamic model/animation resources, 854-855
mechanics), 65-66 online resources
real hours versus estimated hours (burndown game developer salary surveys, 220
charts), 413 Unity tutorials, 852
rebalancing weapons, 177-178 Unity-related websites, 852-853
recursive Bézier curves, 844-845 restarting games, Space SHMUP, 518-519
recursive functions (C# coding), 361-362 reward (inscribed dramatics), 58
Red Dead Redemption Reynolds, Craig W.
climax, example of (dramatic narrative Flocks, Herds, and Schools: A Distributed
structure), 53 Behavior Model, 393
Poker in, 44 OOP (Object-Oriented Programming), 393
rule mechanics, 44 riffle shuffling, 7
Red vs. Blue, machinima example, 83-84 right-clicking and OS X, 265, 849-850
registering Unity, 241-242 RigidBody component (GameObjects), 272, 296
relationships, developing through shared rising action (Act II), five-act dramatic narrative
experiences (dynamic dramatics), 76 structures, 51
releases/sprints (Scrum software development Roberts, Sam, and game definitions, 17
methodologies), 408 RoboCup tournaments, example of player's role
Renderer component (GameObjects), 295 in game design, 62
REPT formula (Calc), showing overall damage RoboRally, innovation and the design process,
(weapons and game balance), 181 97-98
required equipment (paper prototyping and Rock Band, player guidance, 200-201
gameplay development), 132 Rockstar Studios
researching prior art (analysis phase of iterative Grand Theft Auto, resource mechanics, 45
design), 92 Grand Theft Auto V, player guidance, 199
reserve functions (C# coding), 814-815 Red Dead Redemption
resolution (Act III), three-act dramatic narrative climax, example of (dramatic narrative
structure, 52 structure), 53
Poker and rule mechanics, 44
 SCHELL, JESSE 899

Rocky Horror Picture Show, The, and audience rules

participation, 62 FDD framework, 25
Rogers, Scott feel, designing for, 9-10
Disneyland as example of indirect house rules (dynamic mechanics), 66-67
guidance, 202 Inscribed Layer (Layered Tetrad), 40, 44
emergence (Dynamic Layer), mechanics and modifying, Bartok, 8
unexpected emergence, 63-64 Rules of Play: Game Design Fundamentals, 64,
Level Up! The Guide to Great Video Game 120-121
Design, 64, 202 runtime errors, debugging (C# coding), 367-369
Rogue, final outcomes example (dynamic Ryan, Malcolm, and Bartok, 4
mechanics), 69
Rohrer, Jason
attention and involvement as player-centric S
goals of design, 120
salaries in the digital game industry, 220
Passage, 11-12
Salen, Katie
role fulfillment (empathetic characters versus
meaningful play
avatars), 56
defining, 64
roles of players (player relationships),
interesting decisions as a player-centric
defining, 43
goal of design (dynamic procedures),
citizens, 44
120-121
collaborators, 43
Rules of Play: Game Design Fundamentals, 64,
competitors, 43
120-121
multiplayer games, 44
scenes (Unity)
protagonists, 43
saving, 796-797
Romeo and Juliet
Scene pane, 251
empathetic characters versus avatars, 55-56
Schell, Jesse
five-act dramatic narrative structures,
Art of Game Design: A Book of Lenses, The, 4,
example of, 50-51
11, 20, 27
Rooster Teeth Productions, Red vs. Blue
indirectly guiding players, 200-206
machinima example, 83-84
inscribed mechanics, 40-41
ROUND formula (Calc), showing overall damage
interest as a player-centric goal of design,
(weapons and game balance), 181
119
rounds, comparing in Bartok (game play
listening, importance of during design
analysis), 9
phase (iterative design), 93
rows (calc spreadsheets)
Ten Rules of Probability Every Game
creating, 159
Designer Should Know, 165-169
Die A row, 160-161
testing phase (iterative design), 96
Die B row, 161-162
Elemental Tetrad framework, 20, 27-29
labeling, 162-163
aesthetics, 27-28
RPG (Role-Playing Games)
mechanics, 27
Dungeons & Dragons, 846-847
story's role in, 28
FATE system, 846-847
technology's role in, 28
tips for running good campaigns, 846-847
games, defining, 11, 13-14
indirectly guiding players, 200-206
900 SCHELL, JESSE

interest as a player-centric goal of design, Shakespeare, William, and Romeo and Juliet
119 empathetic characters versus avatars, 55-56
listening, importance of during design five-act dramatic narrative structures,
phase (iterative design), 93 example of, 50-51
probability, 165-169 shared experiences, developing relationships
Skyrates, 111-112 through (dynamic dramatics), 76
Ten Rules of Probability Every Game Designer SHMUP (shoot-em-up) games. See Space
Should Know, 165-169 SHMUP
testing phase (iterative design), 96 shorting operators versus non-shorting
schools, Games Education Programs, 215-217 operators (C# coding), 301-302
scoping (design process), 103-104 short-term objectives and space (Inscribed
score counter, Apple Picker, 440-441 Layer mechanics), 46
screen variables (C# coding), 292 shuffling card decks, 7, 172-173
Scripting Reference (Unity), 430-431 side quests and interactive narrative, 54
scripts Sierra OnLine, Space Quest II and autotelic
C# scripts, creating, 266-271 empowerment as a player-centric goal of
formal group playtesting method, 147 design, 117
GameObject components, scripts as, silent protagonists (empathetic characters
296-297 versus avatars), 56
Scrum software development methodologies, similarities, indirectly guiding players by, 201
407, 416 sine/cosine, 822-825
meetings, 409 single player versus game (player interaction
product backlogs/feature lists, 408 patterns), 43
releases/sprints, 408 Singleton software design pattern, 815-816
teams, 408 skills, teaching by player guidance, 207
searches (online), C# resources, 854 integration, 209
second plot point (three-act dramatic narrative sequencing, 207-209
structure), 52 Skyrates
sequencing, teaching players by, 207-209 closed playtesting, 150
serious games, 109 open playtesting, 150-151
setting up projects in Unity, 793, 796 sporadic-play games, 111
C# scripts Skyrim
attaching to scene Main Camera, 797-798 conflicting objectives (Inscribed layer
creating, 797 mechanics), 42
new projects, 794-796 final outcomes (dynamic mechanics),
saving scenes, 796-797 example of, 69
settings, Inscribed Layer (Layered Tetrad), 49 game mods and cultural mechanics, 82
Settlers of Catan importance of objectives (Inscribed layer
resource mechanics, 45 mechanics), 42
strategy, designing for (dynamic narrative game mods, 83
mechanics), 66 player guidance, 198
setup (paper prototyping and gameplay side quests, 54
development), 133 sliding blocks/position puzzles in action
games, 193
 SPEC OPS: THE LINE 901

smell (Inscribed Layer aesthetics), 48 art assets, enemies, 504-506

Snakes and Ladders aspect ratios, 490
aesthetics-based design example, 21-24 backgrounds, 556-558
American name change, 26 boosting weapons, 531-538
strategic game play, modifying for, 23-24 bounds
Factory design pattern, 816 camera bounds, 498-500
Singleton design pattern, 815-816 hero ship bounds, 495-498
Strategy design pattern, 816-817 testing overlapping bounds, 500-504
social change, designing games for, 109 camera setup, 490
social network games and lusory attitude, damaging players, 513-518
111-112 directional light GameObject, 490
Socializer player type (hearts), 67 enemies dropping power-ups, 541-543
software design patterns, 815 enemy attack/damage, 513-518
software development enemy GameObjects, 504-506
Agile methodologies, 405-406, 416 enemy scripts, 506-509, 543-556
Manifesto for Agile Software Development, fine-tuning game play, 559
406-407 function delegate for firing, 525-531
burndown charts, 409 hero shield, 493-495
assigning tasks, 414-415 hero ship, 491-493
BDV (Burndown Velocity), 414-416 importing Unity asset packages, 488-490
creating, 416 layers, 510-513
estimated hours versus real hours, 413 particle effects, 556-558
example of, 410-412 physics, 511-513
prioritizing tasks, 414-415 power-ups, 531-538, 541-543
Scrum methodologies, 407, 416 project setup, 488-490
meetings, 409 race conditions, 538-541
product backlogs/feature lists, 408 restarting games, 518-519
releases/sprints, 408 shooting, 519-531
teams, 408 spawning enemies, 509-510
software, educational software discounts, 855 starfields, 556-558
Somethin' Else, Papa Sangre, sound as an tags, 511-513
Inscribed Layer aesthetic, 47 weapon definitions, 521-525
sought outcomes of probability, 166 spaces, Inscribed Layer (Layered Tetrad), 40, 45
sound experiences, 46
auditory play environments (environmental flow, 45
aesthetics), 73-74 landmark, 45-46
noisy environments, 74 long-term objectives, 46
volume control, 74 medium-term objectives, 46
immediacy of (Inscribed Layer aesthetics), 47 purposes of space, 45
sound effects, 47 short-term objectives, 46
Space Quest II, autotelic empowerment as a Spec Ops: The Line
player-centric goal of design, 117 inscribed dramatics, example of, 57-58
Space SHMUP, 487 limited possibilities and interactive or linear
adding elements, 559-560 narrative, 53-54
adding enemies, 543-556
902 SPEED (SENSE OF)/VECTION, MISSION DEMOLITION

speed (sense of)/vection, Mission Demolition, state tracking, paper game technologies, 59
466-471 static functions (C# coding), 288
Spider-Man 2, quest outcomes (dynamic stealth puzzles, 194
mechanics), example of, 69 Steinkuehler and the cultural aspects of game
spinners (randomization), 170 development, Constance, 80-81
spoilage mechanic (Farmville), 112 Stern and autotelic empowerment as a
Spoilsport player type, 68 player-centric goal of design in Facade,
sporadic-play games and lusory attitude, Andrew, 117
111-112 stories
Spore, procedural animation, 72 Elemental Tetrad framework, story's
spreadsheet programs. See Calc role in, 28
spreadsheets (Calc) FDD framework, 26
cells, entering data, 158-159 story puzzles, 188
columns strategy
adjusting column widths, 160 defining, 65
labeling rows, 162-163 designing for, 66
creating, 158 modifying Snakes and Ladders for strategic
formulas, exiting formula editing, 164 game play, 23-24
rows optimal strategy, determining, 65-66
creating, 159 strategy puzzles, 188
creating Die A row, 160-161 Strategy software design pattern, 816-817
creating Die B row, 161-162 string variables (C# coding), 285
labeling rows, 162-163 structured conflict as a player-centric goal of
sprints/releases (Scrum software development design, 115-116
methodologies), 408 subclasses (C# coding), 388-389, 589-592
sprites and Prospector Solitaire Sudoku, 188
creating cards from sprites, 566-581 Suits, Bernard
importing images as sprites, 564-566 games, defining, 10-15
Stack Overflow website, C# online Grasshopper, The, 10-11, 15, 110-111
resources, 853 lusory attitude, 13-14, 110-111
Star Control, conflicting objectives (Inscribed SUM formula (Calc), 163, 181
layer mechanics), 42 Super Mario Brothers, integrated actions
Star Wars: A New Hope (meaningful play), 64-65
narrative Super Mario Galaxy, particle systems (procedural
premises, examples of, 49 visual art), 71-72
settings, example of, 49 superclasses (C# coding), 388-389, 591
scoping and the design process, 104 Swain, Chris
three-act dramatic narrative structure, FDD framework, 20, 24, 29
example of, 51-52 boundaries, 25
Star Wars: Knights of the Old Republic, limited characters, 26
possibilities and interactive or linear Dramatic elements, 24-26
narrative, 53-54 Dynamic elements, 24, 26-27
Starcraft, game mods and cultural Emergence, 26-27
mechanics, 81-82 Emergent Narrative, 27
Start screen, Apple Picker, 448 Formal elements, 24-25
 THREE-ACT DRAMATIC NARRATIVE STRUCTURE 903

objectives, 25 Team Fortress 2

outcomes, 25 Dynamic Layer (Layered Tetrad) example,
player interaction patterns, 24 36-37
playtesting, 27 freemium games, 214
premises, 25-26 Technique of Dramas, The, five-act dramatic
procedures, 25 structure, 50-51
resources, 25 technology
rules, 25 Cultural Layer (Layered Tetrad), 84
stories, 26 defining, 36
game design, 18 external tools (player-built) and cultural
Game Design Workshop, 10, 18, 20, 24 technology, 84-85
iterative design, 90 game technology used in other fields, 84
Swink, Steve Dynamic Layer (Layered Tetrad), defining, 34
digital prototypes, 420 dynamic technology, 77
Game Feel: A Game Designer's Guide to Virtual Elemental Tetrad framework, 28
Sensation, 420 Inscribed Layer (Layered Tetrad), 58
switch statements (C# coding), 310-313 defining, 33
SystemInfo variables (C# coding), 293 paper game technologies, 58-59
systems thinking, 225, 234 Tekken, fulfilling play as a player-centric goal of
Apple Picker game analysis, 229 game design, 110
GameObject action lists, 231-232 Ten Rules of Probability Every Game Designer
GameObject flowcharts, 232-234 Should Know, 165-169
GameObjects, 230-231 testing phase (iterative design), 91, 95-96. See
gameplay, 230 also playtesting
board games, 226 fastest path to testing, determining (analysis
breaking down complex problems into phase of iterative design), 92
simpler ones, 229 repetition, importance of, 96-97
code libraries, 228 Tetris, 186
computer languages, 227 text
development environment, 228 font-related resources, 855
simple instructions exercise, 226-227 text-based adventure games, loss of
popularity, 117
texture (contrast), indirectly guiding players
T by, 204
That Dragon, Cancer, personal expression/
tables
communication as a goal of game design, 108
Civilization, 40-41
thatgamecompany
Inscribed Layer (Layered Tetrad), 40, 46
Flower, music in, 71
playtest data, 46
Journey, 41, 201-202
probability tables, 46
theoretical probability versus practical
progression tables, 46
probability, 169
Tales of the Arabian Nights, probability tables, 46
three-act dramatic narrative structure
teaching new skills/concepts, sequencing,
antagonism (Act II), 52
207-209
climaxes, 53
team competition (player interaction
exposition (Act I), 52
patterns), 43
904 THREE-ACT DRAMATIC NARRATIVE STRUCTURE

Field, Syd, 51-52

first plot point, 52
U
Foundations of Screenwriting, The, 51-52 Ultima IV, tracking and reacting to (empathetic
hooks, 52 characters versus avatars), 57
inciting incidents, 52 Uncharted
resolution (Act III), 52 inscribed dramatics, example of, 58
second plot point, 52 limited possibilities and interactive or linear
Star Wars: A New Hope as an example of, narrative, 53-54
51-52 role fulfillment (empathetic characters
Tic-Tac-Toe, optimal strategy, determining versus avatars), 56
(dynamic mechanics), 65 Uncharted 2: Drake's Deception, machinima
time-based games, 431-432 example, 84
time-based linear interpolation, 831-832 Uncharted 3
tissue playtesters, 144-145 particle systems (procedural visual art),
Titanfall, researching prior art (analysis phase of 71-72
iterative design), 92 player guidance, 203
Tolkien, J.R.R., Fellowship of the Ring as an unilateral competition (player interaction
emergent narrative example, 77 patterns), 43
Tomb Raider, role fulfillment (empathetic Unity, 235, 237, 251
characters versus avatars), 56 AngryBots project example, 242-246
Tony Hawk's Pro Skater, performative Apple Picker. See Apple Picker
empowerment as a player-centric goal of art assets, Unity Asset Store, 854
design, 118 aspect ratios
top (AAA) games, costs in developing, 213 QuickSnap, 69
touch (Inscribed Layer aesthetics), 47-48 Space SHMUP, 490
tracking (state), paper game technologies, 59 asset packages
trails, indirectly guiding players by, 201 Omega Mage, 729
Transform component (GameObjects), 272, Prospector Solitaire, 562
294-295 QuickSnap, 696-697
transmedia and Cultural Layer (Layered Tetrad), Space SHMUP, 488-490
85-86 Assets folder, 265-266
traversal puzzles, 194 audio assets, Unity Asset Store, 854
Tueber, Klaus axis mapping, InputManager (Unity),
designing for strategy (dynamic 491-494
mechanics), 66 Bézier curves, 842-845
Settlers of Catan, 66 C# coding
tutorials (Unity), 852 attaching scripts to scene Main Camera,
Demo Projects section (Unity website), 852 797-798
Learn section (Unity website), 852 coroutines, 802-803
creating scripts, 266-271, 797
interfaces, 807-810
online resources, 853-854
race conditions, 812-814
 UNITY 905

creating projects in, 264-266 licensing, 241-242

debugging C# coding lightmapping, QuickSnap, 698-701
attaching debugger to Unity, 372-374 linear extrapolation, 836-837
stepping through code, 369-371, 373-377 LineRenderer, ground spells in Omega Mage,
variables, 375-376 756-761
downloading, 236 naming projects, 266
educational software discounts, 855 navigating, 251
equality testing, 304 panes, 251
first-person controllers, QuickSnap, 697-698 configuring layout, 246-251
force-quitting, 371-372 Console pane, 251
functions (C# coding), defining, 350-353 Game pane, 251
GameObjects, 281, 293-294 Hierarchy pane, 251
Box Collider component, 295 Inspector pane, 251
Box Colllider component, 272 Project pane, 251
Capsule Collider component, 295 Scene pane, 251
Collider components, 295-296 particle systems (procedural visual art),
Colllider components, 272 71-72
creating, 271-272 Profiler, 663-665
editing, 272, 277-278 Project pane, creating new projects, 264-266
gizmos, 277 project setup procedures, 793, 796
Mesh Collider component, 295 attaching C# scripts to scene Main Camera,
Mesh Filter component, 272 797-798
Mesh Renderer component, 272 creating C# scripts, 797
Mesh Filter component, 295 new projects, 794-796
playing, 272-273 saving scenes, 796-797
prefabs, 273-277 Project Wizard, new project setup
Renderer component, 295 procedures, 794-796
RigidBody component, 272, 296 Projects folder, viewing contents of, 265
scripts as GameObject components, Prospector Solitaire, importing Unity asset
296-297 packages, 562
Sphere Collider component, 295 QuickSnap, importing Unity asset packages,
Transform component, 272, 294-295 696-697
InputManager, axis mapping, 491-494 reasons for choosing, 237-238
Inspector pane recursive Bézier curves, 844-845
editing GameObjects, 272 registering, 241-242
GameObject components, 294 Scripting Reference, 430-431
installing, 241 sine/cosine, 822-825
interpolation Space SHMUP
easing linear interpolation, 837-841 aspect ratios, 490
interpolating values other than position, importing Unity asset packages, 488-490
834-835 systems thinking and, 228
time-based linear interpolation, 831-832 tutorials, 852
Zeno's Dichotomy Paradox and linear Demo Projects section (Unity website), 852
interpolation, 833-834 Learn section (Unity website), 852
906 UNITY

variables, 287-289 defining, 282-283

color variables, 290-291 equality testing, 304
instance variables, 289 float variables, 284
mathf variables, 292 int variables, 284
quaternion variables, 291-292 literal values, 283
screen variables, 292 naming conventions, 286-287
SystemInfo variables, 293 private variables, 287
Vector3 variables, 288-290 scope of, 286, 817-820
web resources string variables, 285
Goldstone's websites, Will, 853 types of, 283-286
Unity Asset Store, 854 Unity variables, 287-289
Unity Gems website, 852 color variables, 290-291
website instance variables, 289
Demo Projects section (Unity website), 852 mathf variables, 292
Learn section (Unity website), 852 quaternion variables, 291-292
tutorials, 852 screen variables, 292
universities/colleges, Games Education SystemInfo variables, 293
Programs, 215-217 Vector3 variables, 288-290
Up The River vection/sense of speed, Mission Demolition,
inscribed dramatics, example of, 58 466-471
optimal strategy, determining (dynamic Vector3 variables (C# coding), 288-290
mechanics), 65-66 Vectorized Playing Cards 1.3
usability testing, 152 Bartok, 622
user interfaces Prospector Solitaire, 562
Microsoft controllers vertiginous play (Ilinx)
axis mapping, 848-849 Imaginary Games, 110
button mapping, 848-849 Jeux et Le Hommes, Le, and the four different
OS X and right-clicking, 849-850 kinds of play, 110
visibility (paper prototyping and gameplay
development), 133-134, 136
V vision (Inscribed Layer aesthetics), 47
Vissides, John
Valkyrie Chronicles, player guidance, 198
Design Patterns, 769, 815
Valve
software design, 815
Counter Strike, game mods and cultural
Factory design pattern, 816
mechanics, 81-82
Singleton design pattern, 815-816
Half-Life, game mods and cultural
Strategy design pattern, 816-817
mechanics, 81-82
spawning enemies/enemy factories, 769-770
Team Fortress 2, Dynamic Layer (Layered
visual art (procedural), 71-72
Tetrad) example, 36-37
visual design, indirectly guiding players by,
variables (C# coding), 256-257, 282
201-204
bool variables, 283
visual play environments (environmental
char variables, 285
aesthetics), 73
class variables, 286
brightness, 73
debugging C# coding, 375-376
resolution (screen), 73
declaring, 282-283
 WORLD OF WARCRAFT 907

volume control, auditory play environments while loops (C# coding), 316-319
(environmental aesthetics), 74 Williams, John, X-Wing, music in, 70
VRO (Vertical Re-Orchestration), procedural Windows
music, 70-71 force-quitting applications, 317-318,
371-372
Unity, new project setup procedures,
W 794-796
windows (Unity). See panes (Unity)
Warcraft III, game mods and cultural mechanics,
Wittgenstein, Ludwig
81-82
games, defining, 15
wealth as a goal of game design, 107
Philosophical Investigations, 15
weapons and game balance, 177-178
Wizards of the Coast
average damage
Dungeons & Dragons, 846
calculating, 179
dynamic dramatics, 75-77
charting, 179-180
emergent narrative example, 76-77
Chapter 9 prototype example, 182-183
interactive versus linear narrative, 55
duplicating weapon data, 180-181
progression tables, 46
overall damage, showing, 181
tips for running good campaigns, 846-847
percent chance for each bullet,
XP (Experience Points) and cumulative
determining, 178
outcomes (dynamic mechanics), 69
rebalancing weapons, 181-182
RoboRally, innovation and the design
weapons/firing, gameplay development (paper
process, 97-98
prototyping), 134-135, 137-138
Word Game, 657, 692-693
web resources, game developer salary
adding color, 690-692
surveys, 220
adding interactivity, 680-684
websites
animation, 687-690
animation/model resources, 854-855
design goals, 658-659
art assets, 854
layouts, 671-680
audio assets, 854
parsing the word list, 660-663
educational software discounts, 855
project setup, 658
font-related resources, 855
scoring, 684-687
Goldstone's websites, Will, 853
setting up, 664-671
model/animation resources, 854-855
working in the digital game industry, 217
Stack Overflow website, C# online resources,
following up, 218-219
853
interviewing, 219-220
Unity Gems website, 852
networking, 217-218
Unity website
salaries, 220
Learn section (Unity website), 852
working conditions, 213
tutorials, 852
World of Warcraft
weighted distributions and game balance,
player interaction patterns, 43
173-175
player-built external tools as example of
weighted probabilities in Calc, 174-175
cultural technology, 84
Westwood Studios, Blade Runner and multiple
dialogue choices (empathetic characters
versus avatars), 57
908 WRIGHT, WILL

Wright, Will
procedural animation, 72
Spore, 72
Wyatt, James, on XP (Experience Points)
and cumulative outcomes (dynamic
mechanics), 69

X-Y-Z
XML (Extensible Markup Language)
C# coding and, 817-821
Omega Mage, creating the game
environment, 730-735
XP (Experience Points) and cumulative
outcomes (dynamic mechanics), 69
X-Wing
information, conveying (Inscribed Layer
aesthetics), 48-49
music in, 70
Yager Development, Spec Ops: The Line and
limited possibilities and interactive or linear
narrative, 53-54
Yee, Nick, on types of players, 68
Zeno's Dichotomy Paradox and linear
interpolation, 833-834
Zimmerman, Eric
meaningful play, 64, 120-121
Rules of Play: Game Design Fundamentals, 64,
120-121
Zork, interactive narrative example, 75-76
Zubek, Robert, and MDA framework, 20, 29
aesthetics-based design, 21-24
defining, 20-21
designer views of games, 21
player views of games, 21
Zynga, freemium games, 214