Toggle navigation
See also
Home
Programming
Software engineering and computer games
Chapter 12. Listeners
In this chapter we talk about how we move our onscreen player sprite with the mouse and keyboard.
Please enable JavaScript to view the
comments powered by Disqus.
Abbreviations
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 ''cCritterArmed/cCritterBullet'' 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
Remember the name: eTutorials.org
Copyright eTutorials.org 2008-2023. All rights reserved.
