You are previewing Software Engineering and Computer Games.
O'Reilly logo
Software Engineering and Computer Games

Book Description

"This book should be a requirement of anyone that wants to write games ¿ period"
André Lamothe, author and CEO of Xtreme Games

There are many books on the art of games programming but now acclaimed author Rudy Rucker has gone a step beyond and transformed it into a science.

Software Engineering and Computer Games uses an object-oriented (OO) approach throughout, incorporating UML for OO analysis and design and discussing software patterns and how to incorporate them into the design process.

The book covers nine topics:
1) Basic software engineering principles and techniques.
2) How to organize and complete a substantial software project
3) Practical examples of object-oriented design and programming.
4) The design of computer games.
5) Simulating physics inside our computer-generated worlds.
6) Artificial life, or how to simulate live creatures inside a computer program.
7) How to use two and three-dimensional computer graphics.
8) Windows programming with the Microsoft Foundation Classes, or MFC.
9) How to develop a project using Microsoft Visual Studio(Either Version 6.0 or .NET)

The game engine accompanying the book is an open source C++ framework (the POP Framework), available together with other accompanying material from the website.
The book can be used for self-study, with readers encouraged to use the POP Framework as a starting point for creating their own games.

Software Engineering and Computer Games was developed as the primary textbook for an undergraduate software engineering course and can also be the main book for courses on software projects or computer game design and programming.

 

Table of Contents

  1. Copyright
  2. Pearson Education
  3. Foreword
  4. Abbreviations
  5. Acknowledgements
  6. Introduction
  7. Software Engineering and Computer Games
    1. Projects and games
      1. Features of a successful program
      2. Game design
      3. The Pop Framework
      4. Your project
      5. Review questions
      6. Exercises
    2. Basics of software engineering
      1. The Constraint Triangle
      2. Requirements and specifications
      3. The software engineering process
      4. The software lifecycle
      5. Managing your project
      6. Working in teams
      7. Giving a presentation
      8. Review questions
      9. Exercises
    3. The Pop Framework
      1. Object-oriented simulations
      2. Running and testing the Pop program
      3. The Pop source code
      4. The essential Pop classes
      5. UML class diagrams
      6. Using the Pop Framework
      7. Review questions
      8. Exercises
    4. Object-oriented software engineering
      1. OO is the way
      2. Object-oriented analysis
      3. Encapsulation, inheritance, and polymorphism
      4. Composition and delegation
      5. Principles for OO design
      6. The code interface
      7. Review questions
      8. Exercises
    5. Software design patterns
      1. Strategy
      2. Template Method
      3. Command
      4. Composite
      5. Singleton
      6. Bridge
      7. Document-View
      8. Review questions
      9. Exercises
    6. Animation
      1. The endless animation loop
      2. Processor-independent simulation speed
      3. The animation cascade
      4. Updating the views
      5. Review questions
      6. Exercises
    7. Simulating physics
      1. Parallelism
      2. The laws of motion
      3. Force and acceleration
      4. Implementing forces
      5. Preserving your physics
      6. Review questions
      7. Exercises
    8. Critters
      1. Kinds of critters
      2. Overview of the critter class fields
      3. Critter methods
      4. Critter method overrides
      5. The full cCritter prototype
      6. Review questions
      7. Exercises
    9. Sprites
      1. Kinds of sprite
      2. The cSprite class
      3. Polygons
      4. Composite sprites
      5. The cSpriteIcon class
      6. cSpriteLoop and cSpriteDirectional
      7. Review questions
      8. Exercises
    10. Games
      1. The cGame class
      2. The game’s timestep cycle
      3. The virtual methods of cGame
      4. Arrays of critters: the cBiota class
      5. Review questions
      6. Exercises
    11. Collisions
      1. The critter Collide method
      2. Collision-handling
      3. Colliding spheres
      4. Colliding walls
      5. Review questions
      6. Exercises
    12. Listeners
      1. How the critters listen to the user input
      2. The listeners
      3. Shooting with the listeners
      4. Viewer listeners
      5. How a listener initializes its owner critter
      6. Review questions
      7. Exercises
    13. Shooters and bullets
      1. High-level design for cCritterArmed and cCritterBullet
      2. The cCritterArmed
      3. The cCritterBullet
      4. damage and draw
      5. Armed players and armed robots
      6. The two-way cCritterArmed/cCritterBullet association
      7. Review questions
      8. Exercises
    14. 2D shooting games
      1. The Spacewar game
      2. The 2D Game Stub
      3. The Worms game
      4. Exercises
    15. 3D shooting games
      1. The Defender3D specification and design
      2. The Defender3D code
      3. Exercises
    16. Sports games
      1. The Airhockey game
      2. Exercises
    17. Selection games
      1. PickNPop specification and design
      2. The PickNPop implementation
      3. Other selection games
      4. Exercises
    18. Interesting worlds
      1. The Ballworld side-scroller game
      2. Games with walls
      3. Sniffing a trail
      4. Exercises
    19. More ideas for games
      1. Commercial games
      2. The Pop Framework games hall of fame
  8. Software Engineering and Computer Games Reference
    1. Using Microsoft Visual Studio
      1. Navigating with Windows Explorer
      2. Which version?
      3. The Visual Studio user interface
      4. The Visual Studio help files
      5. Correcting compiler and linker errors
      6. Release and Debug builds
      7. Use MFC in static library or use MFC in shared DLL?
      8. Cleanup
      9. Building blocks of a complete program
      10. Profiling with Visual Studio, Version 6.0
      11. Exercises
    2. Tools for software engineering
      1. File names and directory structure
      2. Using the Visual Studio debugger
      3. Windiff and merging code
      4. Counting lines of code
      5. Help files without tears
      6. Exercise
    3. Topics in C++
      1. Classes, objects and constructors
      2. Implicit arguments
      3. Defining a new class
      4. Destructors
      5. The const function declaration
      6. Pass by reference
      7. Instance members and reference members
      8. Parent and child class data
      9. Parent and child constructors and destructors
      10. Virtual methods
      11. Polymorphism
      12. Runtime class information
      13. The scope resolution operator and global functions
      14. Name-mangling
      15. Preprocessor directives
      16. Resizable arrays
      17. Real numbers
      18. A randomizer module
      19. Exercises
    4. Programming Windows with MFC
      1. Some Windows data structures
      2. MFC utility classes
      3. The MFC application framework
      4. Naming conventions
      5. MFC classes are shallow wrappers
      6. Navigating app, doc, and view
      7. Levels of Windows
      8. The MFC program flow
      9. Adjusting the program appearance
      10. The multiple document interface layouts
      11. Splitter views
      12. Portable classes
      13. Exercises
    5. 2D and 3D graphics
      1. Vectors and matrices
      2. The graphics pipeline
      3. Matrices in graphics
      4. Graphics in the Pop Framework
    6. Windows graphics
      1. The Windows sandwich
      2. A CDC is like a cranky six-legged ant
      3. Persistent display
      4. Converting real coordinates to pixel positions
      5. A memory-based device context
      6. Exercises
    7. OpenGL graphics
      1. Linking to OpenGL
      2. The OpenGL state machine
      3. Generic OpenGL code
      4. OpenGL code in Windows
      5. OpenGL in the Pop Framework
    8. Menus and toolbars
      1. Adding menu selections
      2. Toolbar buttons
      3. Accelerator keys
      4. Writing to the status bar
      5. Exercises
    9. Mouse, cursors, and keyboard
      1. Mouse messages
      2. Cursor tools
      3. The mouse wheel
      4. Focus and autofocus
      5. The keyboard
      6. Exercises
    10. Serialization
      1. Serialization summary
      2. Serialization in the Pop Framework
      3. Serialize, operator<<, and operator>>
      4. Serializing an array of pointers
      5. Serializing pointers
      6. The cCritter serialize
      7. Serializing child classes
      8. Serializing a CRuntimeClass
      9. Serializing the view and version
      10. Exercise
    11. Sound
      1. Adding sound to your program
      2. Adding libraries to your project file
      3. An application-wide mute variable
      4. Exercises
    12. Bitmaps
      1. Bitmaps
      2. Using a background bitmap
      3. Transparent bitmaps
  9. The Windows keycodes
  10. The Pop help file
    1. About the Pop program
    2. Updates per second
    3. Overview
    4. Keyboard and mouse controls
    5. Spacewar
    6. PickNPop
    7. Airhockey
    8. Defender3D
    9. Ballworld
    10. Dambuilder
    11. Worms
    12. 2DStub
    13. 3DStub
    14. The cursor tools
    15. The menu controls
    16. The toolbar controls
    17. The status bar
    18. Using the menu and toolbar controls
    19. The motion smoothness dialog
    20. Accelerator keys
    21. Contact information
  11. Summary of the controls for Visual Studio