Software Engineering and Computer Games
- Main Page
- Table of content
- Copyright
- Pearson Education
- Foreword
- Abbreviations
- Acknowledgements
- Introduction
- Part I: Software Engineering and Computer Games
- Chapter 1. Projects and games
- 1.1 Features of a successful program
- 1.2 Game design
- 1.3 The Pop Framework
- 1.4 Your project
- Review questions
- Exercises
- Chapter 2. Basics of software engineering
- 2.1 The Constraint Triangle
- 2.2 Requirements and specifications
- 2.3 The software engineering process
- 2.4 The software lifecycle
- 2.5 Managing your project
- 2.6 Working in teams
- 2.7 Giving a presentation
- Review questions
- Exercises
- Chapter 3. The Pop Framework
- 3.1 Object-oriented simulations
- 3.2 Running and testing the Pop program
- 3.3 The Pop source code
- 3.4 The essential Pop classes
- 3.5 UML class diagrams
- 3.6 Using the Pop Framework
- Review questions
- Exercises
- Chapter 4. Object-oriented software engineering
- 4.1 OO is the way
- 4.2 Object-oriented analysis
- 4.3 Encapsulation, inheritance, and polymorphism
- 4.4 Composition and delegation
- 4.5 Principles for OO design
- 4.6 The code interface
- Review questions
- Exercises
- Chapter 5. Software design patterns
- 5.1 Strategy
- 5.2 Template Method
- 5.3 Command
- 5.4 Composite
- 5.5 Singleton
- 5.6 Bridge
- 5.7 Document-View
- Review questions
- Exercises
- Chapter 6. Animation
- 6.1 The endless animation loop
- 6.2 Processor-independent simulation speed
- 6.3 The animation cascade
- 6.4 Updating the views
- Review questions
- Exercises
- Chapter 7. Simulating physics
- 7.1 Parallelism
- 7.2 The laws of motion
- 7.3 Force and acceleration
- 7.4 Implementing forces
- 7.5 Preserving your physics
- Review questions
- Exercises
- Chapter 8. Critters
- 8.1 Kinds of critters
- 8.2 Overview of the critter class fields
- 8.3 Critter methods
- 8.4 Critter method overrides
- 8.5 The full cCritter prototype
- Review questions
- Exercises
- Chapter 9. Sprites
- 9.1 Kinds of sprite
- 9.2 The cSprite class
- 9.3 Polygons
- 9.4 Composite sprites
- 9.5 The cSpriteIcon class
- 9.6 cSpriteLoop and cSpriteDirectional
- Review questions
- Exercises
- Chapter 10. Games
- 10.1 The cGame class
- 10.2 The game s timestep cycle
- 10.3 The virtual methods of cGame
- 10.4 Arrays of critters: the cBiota class
- Review questions
- Exercises
- Chapter 11. Collisions
- 11.1 The critter Collide method
- 11.2 Collision-handling
- 11.3 Colliding spheres
- 11.4 Colliding walls
- Review questions
- Exercises
- Chapter 12. Listeners
- 12.1 How the critters listen to the user input
- 12.2 The listeners
- 12.3 Shooting with the listeners
- 12.4 Viewer listeners
- 12.5 How a listener initializes its owner critter
- Review questions
- Exercises
- Chapter 13. Shooters and bullets
- 13.1 High-level design for cCritterArmed and cCritterBullet
- 13.2 The cCritterArmed
- 13.3 The cCritterBullet
- 13.4 damage and draw
- 13.5 Armed players and armed robots
- 13.6 The two-way cCritterArmedcCritterBullet association
- Review questions
- Exercises
- Chapter 14. 2D shooting games
- 14.1 The Spacewar game
- 14.2 The 2D Game Stub
- 14.3 The Worms game
- Exercises
- Chapter 15. 3D shooting games
- 15.1 The Defender3D specification and design
- 15.2 The Defender3D code
- Exercises
- Chapter 16. Sports games
- 16.1 The Airhockey game
- Exercises
- Chapter 17. Selection games
- 17.1 PickNPop specification and design
- 17.2 The PickNPop implementation
- 17.3 Other selection games
- Exercises
- Chapter 18. Interesting worlds
- The Ballworld side-scroller game
- 18.2 Games with walls
- 18.3 Sniffing a trail
- Exercises
- Chapter 19. More ideas for games
- 19.1 Commercial games
- 19.2 The Pop Framework games hall of fame
- Part II: Software Engineering and Computer Games Reference
- Chapter 20. Using Microsoft Visual Studio
- 20.1 Navigating with Windows Explorer
- 20.2 Which version?
- 20.3 The Visual Studio user interface
- 20.4 The Visual Studio help files
- 20.5 Correcting compiler and linker errors
- 20.6 Release and Debug builds
- 20.7 Use MFC in static library or use MFC in shared DLL?
- 20.8 Cleanup
- 20.9 Building blocks of a complete program
- 20.10 Profiling with Visual Studio, Version 6.0
- Exercises
- Chapter 21. Tools for software engineering
- 21.1 File names and directory structure
- 21.2 Using the Visual Studio debugger
- 21.3 Windiff and merging code
- 21.4 Counting lines of code
- 21.5 Help files without tears
- Exercise
- Chapter 22. Topics in C
- 22.1 Classes, objects and constructors
- 22.2 Implicit arguments
- 22.3 Defining a new class
- 22.4 Destructors
- 22.5 The const function declaration
- 22.6 Pass by reference
- 22.7 Instance members and reference members
- 22.8 Parent and child class data
- 22.9 Parent and child constructors and destructors
- 22.10 Virtual methods
- 22.11 Polymorphism
- 22.12 Runtime class information
- 22.13 The scope resolution operator and global functions
- 22.14 Name-mangling
- 22.15 Preprocessor directives
- 22.16 Resizable arrays
- 22.17 Real numbers
- 22.18 A randomizer module
- Exercises
- Chapter 23. Programming Windows with MFC
- 23.1 Some Windows data structures
- 23.2 MFC utility classes
- 23.3 The MFC application framework
- 23.4 Naming conventions
- 23.5 MFC classes are shallow wrappers
- 23.6 Navigating app, doc, and view
- 23.7 Levels of Windows
- 23.8 The MFC program flow
- 23.9 Adjusting the program appearance
- 23.10 The multiple document interface layouts
- 23.11 Splitter views
- 23.12 Portable classes
- Exercises
- Chapter 24. 2D and 3D graphics
- 24.1 Vectors and matrices
- 24.2 The graphics pipeline
- 24.3 Matrices in graphics
- 24.4 Graphics in the Pop Framework
- Chapter 25. Windows graphics
- 25.1 The Windows sandwich
- 25.2 A CDC is like a cranky six-legged ant
- 25.3 Persistent display
- 25.4 Converting real coordinates to pixel positions
- 25.5 A memory-based device context
- Exercises
- Chapter 26. OpenGL graphics
- 26.1 Linking to OpenGL
- 26.2 The OpenGL state machine
- 26.3 Generic OpenGL code
- 26.4 OpenGL code in Windows
- 26.5 OpenGL in the Pop Framework
- Chapter 27. Menus and toolbars
- 27.1 Adding menu selections
- 27.2 Toolbar buttons
- 27.3 Accelerator keys
- 27.4 Writing to the status bar
- Exercises
- Chapter 28. Mouse, cursors, and keyboard
- 28.1 Mouse messages
- 28.2 Cursor tools
- 28.3 The mouse wheel
- 28.4 Focus and autofocus
- 28.5 The keyboard
- Exercises
- Chapter 29. Serialization
- 29.1 Serialization summary
- 29.2 Serialization in the Pop Framework
- 29.3 Serialize , operator , and operator
- 29.4 Serializing an array of pointers
- 29.5 Serializing pointers
- 29.6 The cCritter serialize
- 29.7 Serializing child classes
- 29.8 Serializing a CRuntimeClass
- 29.9 Serializing the view and version
- Exercise
- Chapter 30. Sound
- 30.1 Adding sound to your program
- 30.2 Adding libraries to your project file
- 30.3 An application-wide mute variable
- Exercises
- Chapter 31. Bitmaps
- 31.1 Bitmaps
- 31.2 Using a background bitmap
- 31.3 Transparent bitmaps
- Appendix A. The Windows keycodes
- Appendix B. The Pop help file
- About the Pop program
- Updates per second
- Overview
- Keyboard and mouse controls
- Spacewar
- PickNPop
- Airhockey
- Defender3D
- Ballworld
- Dambuilder
- Worms
- 2DStub
- 3DStub
- The cursor tools
- The menu controls
- The toolbar controls
- The status bar
- Using the menu and toolbar controls
- The motion smoothness dialog
- Accelerator keys
- Contact information
- Appendix C. Summary of the controls for Visual Studio