Data Structure For Game Programers Ron Penton pdf

978  100 

Full text

(1)Team LRN.

(2) Team LRN.

(3) Data Structures for Game Programmers. Team LRN.

(4) This page intentionally left blank. Team LRN.

(5) Data Structures for Game Programmers Ron Penton. TM. Team LRN.

(6) © 2003 by Premier Press, a division of Course Technology. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording, or by any information storage or retrieval system without written permission from Premier Press, except for the inclusion of brief quotations in a review. The Premier Press logo and related trade dress are trademarks of Premier Press and may not be used without written permission. TM. Publisher: Stacy L. Hiquet Marketing Manager: Heather Hurley Acquisitions Editor: Emi Smith Project Editor: Karen A. Gill Technical Reviewer: André LaMothe Copyeditor: Stephanie Koutek Interior Layout: LJ Graphics, Susan Honeywell Cover Design: Mike Tanamachi Indexer: Kelly Talbot Proofreader: Jenny Davidson Microsoft, Windows, and Visual C++ are trademarks of Microsoft Corporation.Wolfenstein, Doom, and Quake are trademarks of Id Software, Inc. Warcraft and Starcraft are trademarks of Blizzard Entertainment. The artwork used in this book is copyrighted by its respective owners, and you may not use it in your own commercial works. All other trademarks are the property of their respective owners. Important: Premier Press cannot provide software support. Please contact the appropriate software manufacturer’s technical support line or Web site for assistance. Premier Press and the author have attempted throughout this book to distinguish proprietary trademarks from descriptive terms by following the capitalization style used by the manufacturer. Information contained in this book has been obtained by Premier Press from sources believed to be reliable. However, because of the possibility of human or mechanical error by our sources, Premier Press, or others, the Publisher does not guarantee the accuracy, adequacy, or completeness of any information and is not responsible for any errors or omissions or the results obtained from use of such information. Readers should be particularly aware of the fact that the Internet is an ever-changing entity. Some facts may have changed since this book went to press. ISBN: 1-931841-94-2 Library of Congress Catalog Card Number: 2002111226 Printed in the United States of America 03 04 05 06 07 BH 10 9 8 7 6 5 4 3 2 1 Premier Press, a division of Course Technology 2645 Erie Avenue, Suite 41 Cincinnati, Ohio 45208. Team LRN.

(7) To my family, for always being there for me.. Team LRN.

(8) Acknowledgments. I. would first like to thank my family for putting up with me for the past nine months. Yes, yes, I’ll start cleaning the house now.. I would like to thank all of my friends at school: Jim, James, Dan, Scott, Kevin, and Kelvin, for helping me get through all of those boring classes without falling asleep. I would like to thank everyone at work for supporting me through this endeavor. I especially want to thank Ernest Pazera, André LaMothe, and everyone else at Premier Press for giving me this tremendous opportunity and believing in me. I would like to thank Bruno Sousa for opening the door to writing for me. I want to thank the pioneers of Gamedev.net, Kevin Hawkins and Dave Astle, for paving the road for me and making a book such as this possible. I would like to thank all of you in the #gamedev crew, specifically (in no particular order) Trent Polack, Evan Pipho, April Gould, Joseph Fernald, Andrew Vehlies, Andrew Nguyen, John Hattan, Ken Kinnison, Seth Robinson, Denis Lukianov, Sean Kent, Nicholas Cooper, Ian Overgard, Greg Rosenblatt, Yannick Loitière, Henrik Stuart, Chris Hargrove, Richard Benson, Mat Noguchi, and everyone else! I would like to thank my artists, Steven Seator and Ari Feldman, who made this book’s demos look so much better than they would have been. And finally, I would like to thank the Pepsi Corporation, for making that wonderful “stay awake” juice known as Mountain Dew.. Team LRN.

(9) About the Author Ron Penton’s lifelong dream has always been to be a game programmer. From the age of 11, when his parents bought him his first game programming book on how to make adventure games, he has always striven to learn the most about how games work and how to create them. Ron is currently finishing up his bachelor’s degree in computer science at the State University of New York at Buffalo. He hopes to have a long career in game development.. Team LRN.

(10) Contents at a Glance Introduction . . . . . . . . . . . . . . . . xxxii. Part One. Concepts. . . . . . . . . . . . . . . . . . . . . . . . . 1 Chapter 1 Chapter 2. Basic Algorithm Analysis . . . . . . . . . 3 Templates . . . . . . . . . . . . . . . . . . . 13. Part Two. The Basics. . . . . . . . . . . . . . . . . . . . . . 37 Chapter Chapter Chapter Chapter Chapter Chapter Chapter. 3 4 5 6 7 8 9. Arrays. . . . . . . . . . . . . . . . . . . . . 39 Bitvectors. . . . . . . . . . . . . . . . . . . 83 Multi-Dimensional Arrays . . . . . . . . 107 Linked Lists . . . . . . . . . . . . . . . . . 147 Stacks and Queues . . . . . . . . . . . . 189 Hash Tables . . . . . . . . . . . . . . . . . 217 Tying It Together: The Basics. . . . . . 241. Part Three. Recursion and Trees . . . . . . . . . . . . . . 315 Chapter Chapter Chapter Chapter Chapter. 10 11 12 13 14. Recursion . . . . . . . . . . . . . . . . . . 317 Trees . . . . . . . . . . . . . . . . . . . . . 329 Binary Trees . . . . . . . . . . . . . . . . 359 Binary Search Trees. . . . . . . . . . . 389 Priority Queues and Heaps . . . . . . . 407 Team LRN.

(11) Contents at a Glance. Chapter 15 Chapter 16. Game Trees and Minimax Trees . . . . . 431 Tying It Together: Trees . . . . . . . . 463. Part Four Graphs . . . . . . . . . . . . . . . . . . . . . . 477 Chapter 17 Chapter 18 Chapter 19. Graphs . . . . . . . . . . . . . . . . . . . . 479 Using Graphs for AI: Finite State Machines. . . . . . . . . . . . . . . . . . . 529 Tying It Together: Graphs . . . . . . . 563. Part Five Algorithms . . . . . . . . . . . . . . . . . . . . 597 Chapter 20 Chapter 21 Chapter 22 Chapter 23 Chapter 24 Conclusion. Sorting Data . . . . . . . . . . . . . . . . 599 Data Compression . . . . . . . . . . . . . 645 Random Numbers . . . . . . . . . . . . . 697 Pathfinding . . . . . . . . . . . . . . . . . . 715 Tying It Together: Algorithms . . . . . 769 . . . . . . . . . . . . . . . . . . . . . . . . . 793. Part Six Appendixes . . . . . . . . . . . . . . . . . . . . 799 Appendix A Appendix B Appendix C Appendix D. A C++ Primer . . . . . . . . . . . . . . . . 801 The Memory Layout of a Computer Program . . . . . . . . . . . . . . . . . . . 835 Introduction to SDL. . . . . . . . . . . . 847 Introduction to the Standard Template Library. . . . . . . . . . . . . . . . . . . . 879 Index. . . . . . . . . . . . . . . . . . . . . . 901. Team LRN. ix.

(12) Contents Letter from the Series Editor . . . . . . . . xxx Introduction. . . . . . . . . . . . . . . . . . . . xxxii. Part One. Concepts. . . . . . . . . . . . . . . . . . . . . . . . . 1 Chapter 1 Basic Algorithm Analysis . . . . . . . 3 A Quick Lesson on Algorithm Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Big-O Notation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Comparing the Various Complexities. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 Graphical Demonstration: Algorithm Complexity . . . . . . . . . . . . . . . . . . . . 10 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11. Chapter 2 Templates . . . . . . . . . . . . . . . . . 13 What Are Templates?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 Template Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 Doing It the Old Way . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 Doing It with Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 Template Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 Multiple Parameterized Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 Using Values as Template Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 Using Values of a Specific Datatype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 Using Values of Other Parameterized Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30. Team LRN.

(13) xi. Contents. Problems with Templates. Visual C++ and Templates Under the Hood. . . . . . . . Conclusion . . . . . . . . . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. . . . .. 32 34 34 35. Part Two. The Basics. . . . . . . . . . . . . . . . . . . . . . 37 Chapter 3 Arrays . . . . . . . . . . . . . . . . . . 39 What Is an Array? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 Graphical Demonstration: Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 Increasing or Decreasing Array Size . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 Inserting or Removing an Item . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 Native C Arrays and Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 Static Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 Dynamic Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 An Array Class and Useful Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 The Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 The Constructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 The Destructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 The Resize Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 The Access Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 The Conversion Operator. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 Inserting an Item Between Two Existing Items . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 Removing an Item from the Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 A Faster Removal Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 Retrieving the Size of an Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 Example 3-3. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 Storing/Loading Arrays on Disk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 Writing an Array to Disk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 Reading an Array from Disk. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 Considerations for Writing and Reading Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71. Team LRN.

(14) xii. Contents. Application: Using Arrays to Store Game Data . . . . . . . . . . . . . . . . . . . . . . 71 The Monster Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 Declaring a Monster Array. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 Adding a Monster to the Game. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 Making a Better Insertion Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 Removing a Monster from the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 Checking for Monster Removal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 Playing the Game. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 Analysis of Arrays in Games . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 Cache Issues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 Resizing Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 Inserting/Removing Cells . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80. Chapter 4 Bitvectors . . . . . . . . . . . . . . . . 83 What Is a Bitvector? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 Graphical Demonstration: Bitvectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 The Main Screen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 Using the Buttons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 Creating a Bitvector Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 The Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 The Constructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 The Destructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 The Resize Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 The Access Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 The Set Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 The ClearAll Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 The SetAll Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 The WriteFile Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 The ReadFile Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 Example 4-1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95. Team LRN.

(15) Contents. Application:The Quicksave . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 Creating a Player Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 Storing the Players in the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 Initializing the Data Structures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 Modifying Player Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 Saving the Player Array to Disk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 Playing the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 Bitfields. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 Declaring a Bitfield . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 Using a Bitfield. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 Analysis of Bitvectors and Bitfields in Games . . . . . . . . . . . . . . . . . . . . . . . 105 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106. Chapter 5 Multi-Dimensional Arrays . . . . . . 107 What Is a Multi-Dimensional Array? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 Graphical Demonstration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 Native Multi-Dimensional Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 Declaring a Multi-Dimensional Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 Accessing a Multi-Dimensional Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 Inside a Multi-Dimensional Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 Dynamic Multi-Dimensional Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 The Array2D Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 The Array3D Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 Application: Using 2D Arrays as Tilemaps . . . . . . . . . . . . . . . . . . . . . . . . . . 131 Storing the Tilemap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 Generating the Tilemap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 Drawing the Tilemap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 Playing the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136 Application: Layered Tilemaps. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136 Redefining the Tilemap. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138 Reinitializing the Tilemap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 Modifying the Rendering Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140. Team LRN. xiii.

(16) xiv. Contents. Playing the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 Comparing Performance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 Comparing Size . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144 Analysis of Multi-Dimensional Arrays in Games. . . . . . . . . . . . . . . . . . . . . . . 144 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145. Chapter 6 Linked Lists . . . . . . . . . . . . . . . 147 What Is a Linked List? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148 Singly Linked Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 Graphical Demonstration: Singly Linked Lists. . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 Example 6-4. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168 Final Thoughts on Singly Linked Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 Doubly Linked Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 Graphical Demonstration: Doubly Linked Lists . . . . . . . . . . . . . . . . . . . . . . . . . . 170 Creating a Doubly Linked List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 Doubly Linked List Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 Reading and Writing Lists to Disk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 Writing a Linked List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 Reading a Linked List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 Application: Game Inventories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176 The Player Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 The Item Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 Adding an Item to the Inventory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178 Removing an Item from the Inventory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178 Playing the Demo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 Application: Layered Tilemaps Revisited . . . . . . . . . . . . . . . . . . . . . . . . . . . 180 Declaring the Tilemap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181 Creating the Tilemap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 Drawing the Tilemap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 Analysis and Comparison of Linked Lists . . . . . . . . . . . . . . . . . . . . . . . . . . 184 Algorithm Comparisons. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184. Team LRN.

(17) Contents. Size Comparisons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185 Real-World Issues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188. Chapter 7 Stacks and Queues . . . . . . . . . . 189 Stacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . What Is a Stack? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Graphical Demonstration: Stacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Stack Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementing a Stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Application: Game Menus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Queues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Graphical Demonstration: Queues. . . . . . . . . . . . . . . . . . . . . . . . . . . . The Queue Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementing a Queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Application: Command Queues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . 190 . . . . . . . . 190 . . . . . . . . 192 . . . . . . . . 193 . . . . . . . . 193 . . . . . . . . 199 . . . . . . . 204 . . . . . . . . 204 . . . . . . . . 206 . . . . . . . . 206 . . . . . . . . 212 . . . . . . . 216. Chapter 8 Hash Tables . . . . . . . . . . . . . . . 217 What Is Sparse Data? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218 The Basic Hash Table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 Collisions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221 Hashing Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221 Enhancing the Hash Table Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224 Linear Overflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224 Quadratic Overflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225 Linked Overflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225 Graphical Demonstration: Hash Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226 Implementing a Hash Table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228. Team LRN. xv.

(18) xvi. Contents. The HashEntry Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The HashTable Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Example 8-1: Using the Hash Table. . . . . . . . . . . . . . . . . . . . . . . . . . . . Application: Using Hash Tables to Store Resources . . . . . . . . . . . The String Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Using the Table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . How the Demo Loads Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . Playing the Demo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . 228 . . . . . . . . 229 . . . . . . . . 233 . . . . . . . 235 . . . . . . . . 236 . . . . . . . . 237 . . . . . . . . 237 . . . . . . . . 238 . . . . . . . 239. Chapter 9 Tying It Together: The Basics . . . 241 Why Classes Are Good . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242 Storing Data in a Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243 Hiding Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245 Inheritance. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248 Using the Classes in a Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260 Making a Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265 Adventure:Version One . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266 Game 2—The Map Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314. Part Three. Recursion and Trees . . . . . . . . . . . . . . 315 Chapter 10 Recursion . . . . . . . . . . . . . . . . 317 What Is Recursion? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318 A Simple Example: Powers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319 The Towers of Hanoi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320 The Rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321 Solving the Puzzle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321. Team LRN.

(19) Contents. Solving the Puzzle with a Computer . . . . . . . . . . . . . . . . . . . . . . . . . . Terminating Conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Example 10-1: Coding the Algorithm for Real . . . . . . . . . . . . . . . . . . . Graphical Demonstration:Towers of Hanoi. . . . . . . . . . . . . . . . . . Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . 323 . . . . . . . . 325 . . . . . . . . 325 . . . . . . . 327 . . . . . . . 328. Chapter 11 Trees . . . . . . . . . . . . . . . . . . . 329 What Is a Tree? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330 The Recursive Nature of Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332 Common Structure of Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332 Graphical Demonstration:Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333 Tutorial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336 Building the Tree Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338 The Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339 The Constructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340 The Destructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340 The Destroy Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341 The Count Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342 The Tree Iterator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342 The Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343 The Basic Iterator Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343 The Vertical Iterator Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345 The Horizontal Iterator Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .346 The Other Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346 Building a Tree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347 Top Down . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347 Bottom Up . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347 Traversing a Tree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347 The Preorder Traversal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348 The Postorder Traversal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350 Graphical Demonstration:Tree Traversals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351. Team LRN. xvii.

(20) xviii. Contents. Game Demo 11-1: Plotlines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352 Using Trees to Store Plotlines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354 Playing the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358. Chapter 12 Binary Trees . . . . . . . . . . . . . . 359 What Is a Binary Tree?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360 Fullness . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361 Denseness . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361 Balance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362 Structure of Binary Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362 Linked Binary Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362 Arrayed Binary Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363 Graphical Demonstration: Binary Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . 366 Coding a Binary Tree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368 The Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368 The Constructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369 The Destructor and the Destroy Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369 The Count Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370 Using the BinaryTree Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370 Traversing the Binary Tree. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 The Preorder Traversal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372 The Postorder Traversal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372 The Inorder Traversal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372 Graphical Demonstration: Binary Tree Traversals . . . . . . . . . . . . . . . . . . . . . . . . . 373 Application: Parsing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374 Arithmetic Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376 Parsing an Arithmetic Expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376 Recursive Descent Parsing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377 Playing the Demo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388. Team LRN.

(21) Contents. Chapter 13 Binary Search Trees . . . . . . . . 389 What Is a BST? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390 Inserting Data into a BST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391 Finding Data in a BST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394 Removing Data from a BST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394 The BST Rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394 Sub-Optimal Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 Graphical Demonstration: BSTs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 Coding a BST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397 The Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397 Comparison Functions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397 The Constructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398 The Destructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398 The Insert Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399 The Find Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400 Example 13-1: Using the BST Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401 Application: Storing Resources, Revisited . . . . . . . . . . . . . . . . . . . . . . . . . . 402 The Resource Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402 The Comparison Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403 Inserting Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403 Finding Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403 Playing the Demo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405. Chapter 14 Priority Queues and Heaps. . . . . 407 What Is a Priority Queue? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408 What Is a Heap?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410 Why Can a Heap Be a Priority Queue? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411 Graphical Demonstration: Heaps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417 Coding a Heap Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418. Team LRN. xix.

(22) xx. Contents. The Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419 The Constructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419 The Enqueue Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420 The WalkUp Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420 The Dequeue Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422 The WalkDown Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422 Application: Building Queues. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424 The Units . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426 Creating a Factory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426 The Heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427 Enqueuing a Unit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427 Starting Construction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428 Completing Construction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428 Playing the Demo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430. Chapter 15 Game Trees and Minimax Trees. . . 431 What Is a Game Tree? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432 What Is a Minimax Tree? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434 Graphical Demonstration: Minimax Trees . . . . . . . . . . . . . . . . . . . . . . . . . . 437 Game States. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439 More Complex Games. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442 Application: Rock Piles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442 The Game State . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443 The Global Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445 Generating the Game Tree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446 Simulating Play . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452 Playing the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454 More Complex Games. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456 Never-Ending Games . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456 Huge Games . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459. Team LRN.

(23) Contents. Limited Depth Games . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 460 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 460. Chapter 16 Tying It Together: Trees . . . . . . 463 Expanding the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464 Altering the Map Format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465 Game Demo 16-1: Altering the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 466 The Map Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473 Further Enhancements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475. Part Four. Graphs . . . . . . . . . . . . . . . . . . . . . . 477 Chapter 17 Graphs . . . . . . . . . . . . . . . . . . 479 What Is a Graph? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480 Linked Lists and Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480 Graphs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482 Parts of a Graph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482 Types of Graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482 Bi-Directional Graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483 Uni-Directional Graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483 Weighted Graphs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484 Tilemaps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485 Implementing a Graph. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486 Adjacency Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486 Direction Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488 General-Purpose Linked Graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489 Graphical Demonstration: Graphs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492 Graph Traversals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493. Team LRN. xxi.

(24) xxii. Contents. The Depth-First Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493 The Breadth-First Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495 A Final Word on Graph Traversals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499 Graphical Demonstration: Graph Traversals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500 The Graph Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501 The GraphArc Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501 The GraphNode Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502 The Graph Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504 Application: Making a Direction-Table Dungeon . . . . . . . . . . . . . . . . . . . . . 512 The Map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512 Creating the Map. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513 Drawing the Map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514 Moving Around the Map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516 Playing the Demo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517 Application: Portal Engines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518 Sectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519 Determining Sector Visibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521 Coding the Demo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522 Playing the Demo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528. Chapter 18 Using Graphs for AI: Finite State. Machines . . . . . . . . . . . . . . . . 529 What Is a Finite State Machine? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530 Complex Finite State Machines. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533 Implementing a Finite State Machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535 Graphical Demonstration: Finite State Machines . . . . . . . . . . . . . . . . . . . . 537 Even More Complex Finite State Machines . . . . . . . . . . . . . . . . . . . . . . . . 538 Multiplying States . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538 Conditional Events. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541 Representing Conditional Event Machines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542. Team LRN.

(25) Contents. xxiii. Graphical Demonstration: Conditional Events . . . . . . . . . . . . . . . . . . . . . . 546 Game Demo 18-1: Intruder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547 The Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550 Playing the Demo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 560. Chapter 19 Tying It Together: Graphs . . . . . 563 The New Map Format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564 The New Room Entry Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565 The File Format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566 Game Demonstration 19-1: Adding the New Map Format . . . . . . . . . . . . . 567 The DirectionMap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 568 Changes to the Game Logic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580 Playing the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582 Converting Old Maps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583 The Directionmap Map Editor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584 The Initial Map. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585 Setting and Clearing Tiles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586 Loading a Map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588 Saving a Map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590 Using the Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593 Upgrading the Tilemap Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594 The Save Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594 The Load Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596. Team LRN.

(26) xxiv. Contents. Part Five. Algorithms . . . . . . . . . . . . . . . . . . . . 597 Chapter 20 Sorting Data . . . . . . . . . . . . . . 599 The Simplest Sort: Bubble Sort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 600 Worst-Case Bubble Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601 Graphical Demonstration: Bubble Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602 Coding the Bubble Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 604 The Hacked Sort: Heap Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609 Graphical Demonstration: Heap Sort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611 Coding the Heap Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613 The Fastest Sort: Quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616 Picking the Pivot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616 Performing the Quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618 Graphical Demonstration: Quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621 Coding the Quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623 Graphical Demonstration: Race. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 627 The Clever Sort: Radix Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 630 Graphical Demonstration: Radix Sorts. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 631 Coding the Radix Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633 Other Sorts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 637 Application: Depth-Based Games . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638 The Player Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639 The Globals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 640 The Player Comparison Function. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 640 Initializing the Players. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 640 Sorting the Players. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641 Drawing the Players. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641 Playing the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 643. Team LRN.

(27) Contents. xxv. Chapter 21 Data Compression. . . . . . . . . . . 645 Why Compress Data? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 646 Data Busses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 647 The Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 649 Run Length Encoding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 649 What Kinds of Data Can Be Used for RLE?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 650 Graphical Demonstration: RLEs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 651 Coding an RLE Compressor and Decompressor . . . . . . . . . . . . . . . . . . . . . . . . . 656 Huffman Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 665 Huffman Decoding. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 665 Creating a Huffman Tree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667 Coding a Huffman Tree Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 676 Example 21-3. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 691 Test Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692 Example 21-4. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693 Data Encryption . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693 Further Topics in Compression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 694 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 694. Chapter 22 Random Numbers . . . . . . . . . . . 697 Generating Random Integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 698 Generating Random Numbers in a Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699 Using rand and srand. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 700 Using a Non-Constant Seed Value . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 702 Generating a Random Number Within a Range . . . . . . . . . . . . . . . . . . . . . . . . . . 702 Generating Random Percents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705 Generating Random Floats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 706 Generating Non-Linear Random Numbers. . . . . . . . . . . . . . . . . . . . . . . . . 707 Probability Distribution Graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 707 Adding Two Random Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 709. Team LRN.

(28) xxvi. Contents. Adding Three Random Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711 Graphical Demonstration: Random Distribution Graphs . . . . . . . . . . . . . . . . . . . 712 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 714. Chapter 23 Pathfinding. . . . . . . . . . . . . . . . 715 Basic Pathfinding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 716 Random Bouncing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 718 Object Tracing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719 Robust Pathfinding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 721 The Breadth-First Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 721 Making a Smarter Pathfinder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 739 Making a Better Heuristic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 746 The A* Pathfinder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 750 Graphical Demonstration: Path Comparisons . . . . . . . . . . . . . . . . . . . . . . . . . . . 753 Weighted Maps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 754 Application: Stealth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 756 Thinking Beyond Tile-Based Pathfinding . . . . . . . . . . . . . . . . . . . . . . . . . . 762 Line-Based Pathfinding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 762 Quadtrees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 764 Waypoints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 765 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 767. Chapter 24 Tying It Together: Algorithms . . . 769 Making the Enemies Smarter with Pathfinding . . . . . . . . . . . . . . . . . . . . . 770 Adding Pathfinding to the TileMap Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 771 Adding Pathfinding to the DirectionMap Class. . . . . . . . . . . . . . . . . . . . . . . . . . . 780 Visualizing the GetClosestCell Algorithm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 785 Is That All? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 786 Efficiency . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 790 Playing the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 791 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 791. Team LRN.

(29) Contents. xxvii. Conclusion . . . . . . . . . . . . . . . 793 Extra Topics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 794 Further Reading and References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 795 Data Structure Books . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 795 C++ Books . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 796 Game Programming Books . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 797 Web Sites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 798 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 798. Part Six. Appendixes . . . . . . . . . . . . . . . . . . . . 799 Appendix A. A C++ Primer . . . . . . . . . . . . . . 801 Basic Bit Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 802 Binary Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 802 Computer Storage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 805 Bitwise Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 807 Bitwise Math in C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 807 Bitshifting. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 809 Standard C/C++ Functions Used in This Book . . . . . . . . . . . . . . . . . . . . . . 811 Basic Input/Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 811 File I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 814 Math Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 817 The Time Function. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 818 The Random Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 819 Exceptions and Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 820 Assertions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 820 Return Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 820 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 821 Why C++? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 823. Team LRN.

(30) xxviii. Contents. Class Topics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Constructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Destructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Operator Overloads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Conversion Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The This Pointer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Inline Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Function Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . 824 . . . . . . . . 824 . . . . . . . . 826 . . . . . . . . 827 . . . . . . . . 829 . . . . . . . . 830 . . . . . . . . 830 . . . . . . . . 832 . . . . . . . 833. Appendix B. The Memory Layout of a. Computer Program . . . . . . . . . . 835 The Memory Sections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 836 The Code Memory. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837 The Global Memory. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 838 Global Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 838 Static Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 839 The Stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 840 Local Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 840 Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 842 Return Values. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 843 The Free Store. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 844 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 845. Appendix C. Introduction to SDL . . . . . . . . . 847 The Licensing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 848 Setting Up SDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 849 The Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 849 Setting Up the Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 850 Setting Up Visual C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 851 Setting Up Your Project . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853. Team LRN.

(31) Contents. xxix. Setting Up SDL_TTF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 856 Distributing Your Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 858 Using SDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 858 SDL_Video . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 858 SDL Event Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 861 SDL_Timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 863 SDL_TTF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 863 The SDLHelpers Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 865 The SDLFrame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 867 The SDLGUI Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 869 The SDLGUI Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 869 The SDLGUIItem Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 874 The SDLGUI Items . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 876 The SDLGUIFrame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 876 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 878. Appendix D. Introduction to the Standard. Template Library . . . . . . . . . . . 879 STLPort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 880 STL Versus This Book. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 882 Namespaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 883 The Organization of STL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 885 Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 889 Sequence Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 890 Associative Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 896 Container Adaptors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 896 The Miscellaneous Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 898 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 899. Index. . . . . . . . . . . . . . . . . . . . . . . . . 901. Team LRN.

(32) xxx. Letter from the Series Editor. Letter from the Series Editor Dear reader, I’ve always wanted to write a book on data structures. However, there is simply no way to do the job right unless you use graphics and animation, and that means a lot of work. I personally think that all computer books will be animated, annotated, and interactive within 10 years—they have to be. There is simply too much information these days to convey with text alone; we need to use graphics, color, sound, animation—anything and everything to try to make the complex computer science subjects understandable these days. With that in mind, I wanted a data structures book that was like no other—a book using today’s technology that could live up to my high standards. So I set out to find the perfect author and finally Ron Penton came along to take on the challenge. Ron, too, had my same vision for a data structures book. We couldn’t do something that had been done—there are a zillion boring data structure books—but if we could apply gaming technology and graphics to teach the subject, we would have something unique. Moreover, this book is for anyone who wants to learn data structures and related important algorithms. Sure, if you’re a game programmer then you will feel at home, but if you’re not, then believe me, put down that hardbound college text and pick this book up because not only will you absolutely know this stuff inside and out by the time you’re done, but you will have an image in your mind like you have never had before. All right, now I want to talk about what you’re going to find inside. First, Ron has really outdone himself with the demonstrations in this book. I would have been happy with little dots moving around and some arrows, but he has created an entire system to build the book demos in so that you can see the data structures working and the algorithms processing them. It’s simply amazing to actually see bubble sort, quick sort, heap sort, and so on all race each other, or the insertion and deletion of nodes in a tree. Only a game programmer could bring these and more to you—no one else would have the programming mastery of all the fields necessary to. Team LRN.

(33) xxxi. Letter from the Series Editor. pull this off. On the other hand, if you are a game programmer, then you will greatly appreciate Ron’s insight into applications of various data structures and algorithms for game-related programs. In fact, he came up with some pretty cool applications I hadn’t thought of! So what’s inside? Well, the book starts off with an introduction, gets you warmed up with arrays, bit vectors, and simple stuff like that, and talks about the use of SDL (the simple direct media layer) used for the demos. Then the book drives a steak through the heart of the data structure dragon and covers asymptotic analysis, linked lists, queues, heaps, binary trees, graphs, hash tables, and the list goes on and on. After Ron has made you a believer that hash tables are the key to the universe, he switches gears to algorithms and covers many of the classic algorithms in computer science, such as sorting, searching, compression, and more. Of course, no book like this would be complete without coverage of recursion, and that’s in here, too—but you will love it because for once, you will be able to see the recursion! Finally, the book ends with primers on C++, SDL, and the standard template library, so basically you will be a data structure god when you’re done! In conclusion, this book is for the person who is looking for both a practical and a theoretical base in data structures and algorithms. I guarantee that it will get you farther from ground zero than anything else.. André LaMothe Series Editor. Team LRN. xxxi.

(34) Introduction What is a computer program? When you get down to the lowest level, you can separate a program into two main sections: the data and the instructions that operate on the data. These two sections of a program are commonly called the data structures and the algorithms. This book will teach you how to create many data structures, ranging from the very simple to the moderately complex. Understanding data structures and algorithms is an essential part of game programming. Knowing the most efficient way to store data and work with the data is an important part of game programming; you want your games to run as quickly as possible so you can pack as many cool features into them as you can. I have a few goals with this book: ■ ■ ■. Teach you how the most popular data structures and algorithms work Teach you how to make the structures and algorithms Teach you how to use the data structures in computer games. Mark Twain once said this: It is a good thing, perhaps, to write for the amusement of the public. But it is a far higher and nobler thing to write for their instruction. I have always tried to help people whenever they need it. However, most of my help has been interactive—in chat rooms or in person. People ask me questions, and I answer them. If they don’t understand, I can explain it better. A book is a different format for me because you cannot ask me a question if there is something you don’t understand. So I have used the only method I can think of to prevent you from needing to ask questions: I explain everything. Well, not quite everything because that is pretty much impossible, but I have tried to explain as much as possible to help you understand things better.. Team LRN.

(35) Introduction. xxxiii. Who Is This Book For?. If you’re standing in the bookstore reading this Introduction and wondering, “Is this book good for me?”, then read this section. If you’ve already bought the book, thank you! I am going to assume that you’re reading this book because you want to learn more (unless some diabolical person is forcing you to read this as an arcane form of torture...). This is a somewhat complex book because it deals with lots of concepts. However, I feel that I have included ample introductory material as well. Therefore, this book is for the game programmer who is just starting out at an intermediate level. So what do I expect you to know? I expect you to know basic C++, but don’t feel confused if you don’t feel like an expert. Pretty much every complex topic I use in C++ is covered in Appendix A, so if you’re unfamiliar with a concept or just forget how something works, take a few minutes to read that appendix. The most complex feature of C++ that I use is templates, but you don’t need to know about them before you read this book. Chapter 2 is an extensive introduction to templates, so don’t worry if you don’t know what they are just yet. One advanced concept I use often in the later parts of the book is recursion, but you don’t have to know about that, either. Chapter 10 is a small introduction to recursion. This book is for anyone who wants to learn more about how a computer works, how to store data, and how to efficiently work on that data. All of this material is essential to game programming, so take a glance at the Table of Contents. If there is anything there that you don’t already know about, this book is for you. Even if you know a little about the topics, this book is still good for you because every chapter goes in depth about these subjects.. Topics Covered in This Book. In this book, I cover many data structures and how to use them in games, ranging from the simple (arrays) to the complex (graphs and trees). I have tried to make every chapter follow a certain format. First, I begin explaining the data structure or algorithm in theory so that you can see how it works and why it works. After that, I show you an interactive Graphical Demonstration of the structure, which is a demo on the CD that you can play around with to help you. Team LRN.

Figure

Figure I.1 This is the way
Figure I 1 This is the way . View in document p.41
Figure 1.1
Figure 1 1 . View in document p.49
Figure 1.7 The base-2 exponential function is
Figure 1 7 The base 2 exponential function is . View in document p.52
Figure 1.6 The n3 function has an even
Figure 1 6 The n3 function has an even . View in document p.52
Figure 2.1 Using templates, you
Figure 2 1 Using templates you . View in document p.59
Figure 2.5 This demonstrates the chaos
Figure 2 5 This demonstrates the chaos . View in document p.69
Figure 2.7 shows how three different
Figure 2 7 shows how three different . View in document p.72
Figure 2.10
Figure 2 10 . View in document p.78
Figure 3.4 There are more fence posts
Figure 3 4 There are more fence posts . View in document p.88
Figure 3.5 Here are the
Figure 3 5 Here are the . View in document p.89
Figure 3.13
Figure 3 13 . View in document p.111
Figure 3.14
Figure 3 14 . View in document p.121
Figure 3.15
Figure 3 15 . View in document p.122
Figure 3.16
Figure 3 16 . View in document p.123
Figure 4.2 This is the main
Figure 4 2 This is the main . View in document p.130
Figure 4.7 The g_modifiedstates
Figure 4 7 The g modifiedstates . View in document p.145
Figure 4.8 This is a screenshot
Figure 4 8 This is a screenshot . View in document p.146
Figure 5.1 The three common
Figure 5 1 The three common . View in document p.153
Figure 5.3
Figure 5 3 . View in document p.154
Figure 5.4 This is a screenshot
Figure 5 4 This is a screenshot . View in document p.155
Figure 5.6 This figure shows
Figure 5 6 This figure shows . View in document p.160
Figure 5.7 This is how you
Figure 5 7 This is how you . View in document p.160
Figure 5.8
Figure 5 8 . View in document p.161
Figure 5.11
Figure 5 11 . View in document p.176
Figure 5.12
Figure 5 12 . View in document p.180
Figure 5.13
Figure 5 13 . View in document p.181
Figure 5.14
Figure 5 14 . View in document p.182
Figure 5.16  This is
Figure 5 16 This is . View in document p.187
Figure 5.17
Figure 5 17 . View in document p.189
Figure 6.2 Here is a screenshot
Figure 6 2 Here is a screenshot . View in document p.194

References

Updating...

Download now (978 pages)