Game programming patterns and the structure of the Scrolling Shooter project
by John Horton
Learning Java by Building Android Games - Second Edition
- Learning Java by Building Android Games - Second Edition
- Table of Contents
- Learning Java by Building Android Games Second Edition
- Contributors
- Preface
- 1. Java, Android and Game Development
- What's new in the second edition?
- Why Java, Android and Games?
- The games you will build
- How Java and Android work
- Setting up Android Studio
- Starting the first project: Sub' Hunter
- Android Studio and our project – A very brief guided tour
- Locking the game to full-screen and landscape orientation
- Deploying the game so far
- Summary
- 2. Java: First Contact
- 3. Variables, Operators and Expressions
- 4. Structuring Code with Java Methods
- 5. The Android Canvas Class – Drawing to the Screen
- 6. Repeating Blocks of Code with Loops
- 7. Making Decisions with Java If, Else and Switch
- 8. Object-Oriented Programming
- Basic Object-Oriented Programming
- Looking at the code for a class
- Basic classes mini-app
- Remember that encapsulation thing?
- Encapsulation and static methods mini-app
- OOP and inheritance
- Inheritance mini-app
- Polymorphism
- Starting the Pong game
- Summary
- 9. The Game Engine, Threads, and The Game Loop
- Coding the PongActivity class
- Coding the PongGame class
- Coding the PongGame class
- The game loop
- Threads
- Implementing the game loop with a thread
- Implementing Runnable and providing the run method
- Coding the thread
- Starting and stopping the thread
- Activity lifecycle
- A simplified explanation of the Android lifecycle
- Lifecycle phases: What we need to know
- Lifecycle phases: What we need to do
- Using the Activity lifecycle to start and stop the thread
- Coding the run method
- Running the game
- Summary
- 10. Coding the Bat and Ball
- 11. Collisions, Sound Effects and Supporting Different Versions of Android
- 12. Handling Lots of Data with Arrays
- 13. Bitmap Graphics and Measuring Time
- 14. The Stack, the Heap, and the Garbage Collector
- 15. Android Localization -Hola!
- 16. Collections, Generics and Enumerations
- 17. Manipulating Bitmaps and Coding the Snake class
- 18. Introduction to Design Patterns and much more!
- Introducing the Scrolling Shooter project
- Game programming patterns and the structure of the Scrolling Shooter project
- Starting the project
- Controlling the game with a GameState class
- Giving partial access to a class using an interface
- Building a sound engine
- Testing the game so far
- Building a HUD class to display control buttons and text
- Building a Renderer class to handle the drawing
- Using the HUD and Renderer classes
- Running the game
- Summary
- 19. Listening with the Observer Pattern, Multitouch and Building a Particle System
- 20. More Patterns, a Scrolling Background and Building the Player's ship
- Meet the game objects
- The Entity-Component pattern
- The Simple Factory pattern
- Summary so far
- The object specifications
- Coding the component Interfaces
- Coding the player's and the background's empty component classes
- Every GameObject has a transform
- Every object is a GameObject
- Completing the player's and the background's components
- Building the GameObjectFactory
- Coding the Level class
- Putting everything together
- Running the game
- Summary
- 21. Completing the Scrolling Shooter Game
- 22. Exploring More Patterns and Planning the Platformer Project
- Platform Game: Bob Was in A Hurry
- How we will build the platformer
- Getting started with Bob was in a hurry
- Specifying all the game objects with GameObjectSpec classes
- GameObjectSpec
- BackgroundCitySpec
- BackgroundMountainSpec
- BackgroundUndergroundSpec
- BrickTileSpec
- CartTileSpec
- CoalTileSpec
- CollectibleObjectSpec
- ConcreteTileSpec
- DeadTreeTileSpec
- FireTileSpec
- GrassTileSpec
- LamppostTileSpec
- MoveablePlatformSpec
- ObjectiveTileSpec
- PlayerSpec
- ScorchedTileSpec
- SnowTileSpec
- SnowyTreeTileSpec
- StalactiteTileSpec
- StalagmiteTileSpec
- StonePileTileSpec
- Summary of component classes
- Coding the component interfaces
- Coding the other interfaces
- Summary
- 23. The Singleton Pattern, Java HashMap, Storing Bitmaps Efficiently and Designing Levels
- The Singleton pattern
- More Java Collections – Meet Java Hashmap
- The memory problem and the BitmapStore
- Coding the basic transform
- Coding the inanimate and decorative components
- Create the levels
- Coding a stripped down GameObjectFactory
- Coding a slightly commented-out game object
- Coding the GameState
- Code the SoundEngine
- Coding the physics engine (without collision)
- Coding a Renderer
- Coding the camera
- Coding the Hud
- Coding the UIController class
- Code the Activity
- Code the GameEngine
- Coding the LevelManager class
- Running the game
- Summary
- 24. Sprite-sheet animations, Controllable Player and Parallax Scrolling Backgrounds
- 25. Intelligent Platforms and Advanced Collision Detection
- 26. What next?
- Index
Before we dive in too deeply it is probably worth stating exactly what a design pattern is.
What makes design patterns special is that the solutions have already been found by someone else. Documented in books and other media (like websites) and they even have names, so they can be readily discussed.
There are lots of design patterns. We will be learning about the Observer, Strategy/Entity-Component, Singleton and Factory design patterns.
Design patterns are already proven ways of enabling the ideas we have already discussed. Like reusing code, encapsulating code and designing classes that represent things. Patterns often amount to a best-practice way of encapsulating, allowing re-use and yet allowing a group of classes to interact.
Design patterns are used in all languages and across all types of software development. The key to design patterns is to simply know that they exist and roughly what problem(s) each of them solves. Then when you see a flaw in the structure of your code you can then go and investigate a particular pattern.
Tip
The other great thing about design patterns is that by learning and then using common solutions to common problems a design pattern also becomes a means of communication between developers. "Hey Fred, why don't we try implementing an Observer based solution to that communication problem on the Widget project?"
Throughout the rest of the book as we are introduced to design patterns, we will also examine the problem which caused us to need the pattern in the first place.
-
No Comment