Learning Java by Building Android Games

Cover
Title Page
Copyright
Contributors
Table of Contents
Preface
Chapter 1: Java, Android, and Game Development
	Technical requirements
		Windows
		Mac
		Linux
	What's new in the third edition?
	Why Java, Android, and games?
		The Java stumbling block
	The games we will build
		Sub' Hunter
		Pong
		Bullet Hell
		Snake Clone
		Scrolling Shooter
	How Java and Android work together
		Run that by me again – what, exactly, is Android?
	Setting up Android Studio
	Starting the first project – Sub' Hunter
	Android Studio and our project – a very brief guided tour
		The Project panel
		The Editor window
	Refactoring MainActivity to SubHunter
	Locking the game to full screen and landscape orientation
	Amending the code to use the full screen and the best Android class
	Deploying the game so far
		Running the game on an Android emulator
		Running the game on a real device
	Summary
Chapter 2: Java – First Contact
	Planning the Sub' Hunter game
		The actions flowchart/diagram
		Mapping out our code using comments
	Introducing Java methods
		Overriding methods
	Structuring Sub' Hunter with methods
	Introducing OOP
		Classes and objects
		Classes, objects, and instances
		A final word on OOP, classes, and objects – for now
	Using Java packages
		Adding classes by importing packages
	Linking up our methods
	Summary
Chapter 3: Variables, Operators, and Expressions
	Handling syntax and jargon
	Java variables
		Different types of variables
	How to use variables
		Declaring variables
		Initializing variables
	Making variables useful with operators
		Most used operators in this book
	Declaring and initializing the Sub' Hunter variables
		Planning the variables
		Declaring the variables
		Handling different screen sizes and resolutions
		Handling different screen resolutions, part 1 – initializing the variables
	Errors, warnings, and bugs
		Printing debugging information
	Testing the game
	Summary
Chapter 4: Structuring Code with Java Methods
	Methods
		Methods revisited and explained further
	Method overloading by example
		Creating a new project
		Coding the method overloading mini-app
		Running the method overloading mini-app
	Scope – methods and variables
		Method recursion
		Revisiting the code and methods we have used already
	Generating random numbers to deploy a sub
		The Random class and the nextInt method
	Testing the game
	Summary
Chapter 5: The Android Canvas Class – Drawing to the Screen
	Understanding the Canvas class
		Getting started drawing with Bitmap, Canvas, and ImageView
	Using the Canvas class
		Preparing the objects of classes
		Initializing the objects
		Setting the Activity content
	Canvas Demo app
		Creating a new project
	Android coordinate system
		Plotting and drawing
	Drawing the Sub' Hunter graphics and text
		Preparing to draw
		Initializing Canvas, Paint, ImageView, and Bitmap objects
		Drawing some gridlines
		Drawing the HUD
		Upgrading the printDebuggingText method
	Summary
Chapter 6: Repeating Blocks of Code with Loops
	Making decisions with Java
	Keeping things tidy
	More operators
	Java loops
		While loops
		Do while loops
		For loops
	Using for loops to draw the Sub' Hunter grid
	Summary
Chapter 7: Making Decisions with Java If, Else, and Switch
	If they come over the bridge, shoot them
		Else do this instead
	Switching to make decisions
		Switch example
	Combining different control flow blocks
		Using the continue keyword
	Making sense of screen touches
		Coding the onTouchEvent method
	Final tasks
		Coding the takeShot method
		Explaining the takeShot method
		Coding the boom method
		Drawing the shot on the grid
	Running the game
	Summary
Chapter 8: Object-Oriented Programming
	Basic object-oriented programming
		Humans learn by doing
		Introducing OOP
		Why do we do it like this?
		Class recap
	Looking at the code for a class
		Class implementation
		Declaring, initializing, and using an object of the class
	Basic classes mini-app
		Creating your first class
		More things we can do with our first class
	Encapsulation
		Controlling class use with access modifiers
		Controlling variable use with access modifiers
		Methods have access modifiers too
		Accessing private variables with getters and setters
		Setting up our objects with constructors
		Using "this"
		Static methods
	Encapsulation and static methods mini-app
	OOP and inheritance
	Inheritance mini-app
	Polymorphism
		Abstract classes
		Interfaces
	Starting the Pong game
		Planning the Pong game
		Setting up the Pong project
	Refactoring MainActivity to PongActivity
	Locking the game to fullscreen and landscape orientation
	Amending the code to use the full screen and the best Android class
	Summary
Chapter 9: The Game Engine, Threads, and the Game Loop
	Coding the PongActivity class
	Coding the PongGame class
	Thinking ahead about the PongGame class
		Adding the member variables
		Coding the PongGame constructor
		Coding the startNewGame method
		Coding the draw method
		Understanding the draw method and the SurfaceView class
	The game loop
	Getting familiar with threads
		Problems with threads
		Java try-catch exception handling
	Implementing the game loop with a thread
		Implementing Runnable and providing the run method
		Coding the thread
		Starting and stopping the thread
		The 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
Chapter 10: Coding the Bat and Ball
	The Ball class
		Communicating with the game engine
		Representing rectangles and squares with RectF
		Coding the variables
		Coding the Ball constructor
		Coding the RectF getter method
		Coding the Ball update method
		Coding the Ball helper methods
		Coding a realistic-ish bounce
		Using the Ball class
	The Bat class
		Coding the Bat variables
		Coding the Bat constructor
		Coding the Bat helper methods
		Coding the Bat's update method
		Using the Bat class
	Coding the Bat input handling
	Running the game
	Summary
Chapter 11: Collisions, Sound Effects, and Supporting Different Versions of Android
	Handling collisions
		Collision detection options
		Optimizing the detection methods
		Best options for Pong
		The RectF intersects method
	Handling different versions of Android
		Detecting the current Android version
	The SoundPool class
		Initializing SoundPool the new way
	Generating sound effects
	Adding sound to the Pong game
		Adding the sound variables
		Initializing the SoundPool
	Coding the collision detection and playing sounds
		The bat and the ball
		The four walls
	Playing the game
	Summary
Chapter 12: Handling Lots of Data with Arrays
	Planning the project
	Starting the project
	Refactoring MainActivity to BulletHellActivity
	Locking the game to full-screen and landscape orientation
	Amending the code to use the full screen and the best Android class
		Creating the classes
	Reusing the Pong engine
		Coding the BulletHellActivity class
		Coding the BulletHellGame class
		Testing the Bullet Hell engine
	Coding the Bullet class
		Spawning a bullet
	Getting started with Java arrays
		Arrays are objects
		Simple array example mini-app
	Getting dynamic with arrays
		Dynamic array example
	Entering the nth dimension with arrays
		Multidimensional array mini app
		Array out of bounds exceptions
	Spawning an array of bullets
		Running the game
	Summary
Chapter 13: Bitmap Graphics and Measuring Time
	The Bob (player's) class
		Add the Bob graphic to the project
		Coding the Bob class
		Using the Bob class
		Coding the spawnBullet method (again)
	Running the game
	The Android Studio Profiler tool
	Summary
Chapter 14: Java Collections, the Stack, the Heap, and the Garbage Collector
	Managing and understanding memory
		Variables revisited
	Introduction to the Snake game
		Looking ahead to the Snake game
	Getting started with the Snake game
	Refactoring MainActivity to SnakeActivity
	Locking the game to fullscreen and landscape orientation
		Adding some empty classes
		Coding SnakeActivity
		Adding the sound effects
	Coding the game engine
		Coding the members
		Coding the constructor
		Coding the newGame method
		Coding the run method
		Coding the updateRequired method
		Coding the update method
		Coding the draw method
		Coding the OnTouchEvent method
		Coding pause and resume
	Running the game
	Summary
Chapter 15: Android Localization – Hola!
	Making the Snake game Spanish, English, or German
		Adding Spanish support
		Adding German support
		Adding the string resources
		Amending the Java code
	Running the game in German or Spanish
	Summary
Chapter 16: Collections and Enumerations
	Adding the graphics
	Coding the Apple class
		The Apple constructor
	Using the Apple class
		Running the game
	Using arrays in the Snake game
		Understanding ArrayList class
		The enhanced for loop
	Arrays and ArrayLists are polymorphic
	Introducing enumerations
	Summary
Chapter 17: Manipulating Bitmaps and Coding the Snake Class
	Rotating Bitmaps
		What is a Bitmap exactly?
		The Matrix class
	Adding the sound to the project
	Coding the Snake class
		Coding the constructor
		Coding the reset method
		Coding the move method
		Coding the detectDeath method
		Coding the checkDinner method
		Coding the draw method
		Coding the switchHeading method
		Using the snake class and finishing the game
	Running the completed game
	Summary
Chapter 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
	Refactoring MainActivity to GameActivity
	Locking the game to fullscreen and landscape orientation
		Coding the GameActivity class
		Getting started on the GameEngine class
	Controlling the game with a GameState class
		Passing GameState from GameEngine to other classes
		Communicating from GameState to GameEngine
	Giving partial access to a class using an interface
		Interface refresher
		What we will do to implement the interface solution
		Coding the GameState class
		Saving and loading the high score forever
		Pressing the "special button" – calling the method of the interface
		Finishing off the GameState class
		Using the GameState class
	Building a sound engine
		Adding the sound files to the project
		Coding the SoundEngine class
		Using the SoundEngine class
	Testing the game so far
	Building a HUD class to display the player's control buttons and text
		Coding the prepareControls method
		Coding the draw method of the HUD class
		Coding drawControls and getControls
	Building a Renderer class to handle the drawing
	Using the HUD and Renderer classes
	Running the game
	Summary
Chapter 19: Listening with the Observer Pattern, Multitouch, and Building a Particle System
	The Observer pattern
		The Observer pattern in the Scrolling Shooter project
	Coding the Observer pattern in Scrolling Shooter
		Coding the Broadcaster interface
		Coding the InputObserver interface
		Making GameEngine a broadcaster
	Coding a multitouch UI controller and making it a listener
		Coding the required handleInput method
		Using UIController
	Running the game
	Implementing a particle system explosion
		Coding the Particle class
		Coding the ParticleSystem class
		Adding a particle system to the game engine and drawing it with the Renderer class
	Building a physics engine to get things moving
	Running the game
	Summary
Chapter 20: More Patterns, a Scrolling Background, and Building the Player's Ship
	Meeting the game objects
		A reminder of how all these objects will behave
	The Entity-Component pattern
		Why lots of diverse object types are hard to manage
		The first coding nightmare
		Using a generic GameObject for better code structure
		Composition over inheritance
	The Simple Factory pattern
		At last, some good news
	Summary so far
	The object specifications
		Coding the ObjectSpec parent class
		Coding all the specific object specifications
	Coding the component interfaces
		GraphicsComponent
		InputComponent
		MovementComponent
		SpawnComponent
	Coding the player's and the background's empty component classes
		StdGraphicsComponent
		PlayerMovementComponent
		PlayerSpawnComponent
		PlayerInputComponent and the PlayerLaserSpawner interface
		LaserMovementComponent
		LaserSpawnComponent
		BackgroundGraphicsComponent
		BackgroundMovementComponent
		BackgroundSpawnComponent
	Every GameObject has a transform
	Every object is a GameObject
	Completing the player's and the background's components
		The player's components
		Coding a scrolling background
		GameObject/Component reality check
	Building the GameObjectFactory class
	Coding the Level class
	Putting everything together
		Updating GameEngine
		Updating PhysicsEngine
		Updating the renderer
	Running the game
	Summary
Chapter 21: Completing the Scrolling Shooter Game
	Adding the alien's components
		AlienChaseMovementComponent
		AlienDiverMovementComponent
		AlienHorizontalSpawnComponent
		AlienPatrolMovementComponent
		AlienVerticalSpawnComponent
	Spawning the aliens
		Updating the GameEngine class
		Updating the Level class
		Updating the GameObjectFactory class
	Running the game
	Detecting collisions
	Running the completed game
	Summary
Chapter 22: What Next?
	Publishing
	Using the assets from the book
	Future learning
	My other channels
	Thanks
	Why subscribe?
About Packt
Other Books You May Enjoy
Index