Book Image

Learning Java by Building Android Games - Second Edition

By : John Horton
Book Image

Learning Java by Building Android Games - Second Edition

By: John Horton

Overview of this book

Android is one of the most popular mobile operating systems presently. It uses the most popular programming language, Java, as the primary language for building apps of all types. However, this book is unlike other Android books in that it doesn’t assume that you already have Java proficiency. This new and expanded second edition of Learning Java by Building Android Games shows you how to start building Android games from scratch. The difficulty level will grow steadily as you explore key Java topics, such as variables, loops, methods, object oriented programming, and design patterns, including code and examples that are written for Java 9 and Android P. At each stage, you will put what you’ve learned into practice by developing a game. You will build games such as Minesweeper, Retro Pong, Bullet Hell, and Classic Snake and Scrolling Shooter games. In the later chapters, you will create a time-trial, open-world platform game. By the end of the book, you will not only have grasped Java and Android but will also have developed six cool games for the Android platform.

Related Content you might be interested in

Current Title:

Small book image
Learning Java by Building Android Games - Second Edition
John Horton
Aug, 2018 | 774 pages
Small book image
Android Programming for Beginners
John Horton
Apr, 2021 | 742 pages
Small book image
Learning Java by Building Android Games
John Horton
Jan, 2015 | 392 pages
Small book image
Android Programming for Beginners
John Horton
Dec, 2015 | 698 pages
Table of Contents (30 chapters)
Learning Java by Building Android Games Second Edition
Learning Java by Building Android Games Second Edition
Contributors
Contributors
Preface
Preface
Free Chapter
1
Java, Android and Game Development
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
Java: First Contact
Planning the Sub' Hunter game
Introduction to Java methods
Structuring Sub' Hunter with methods
Introduction to Object Oriented Programming
Using Java packages
Linking up our methods
Summary
3
Variables, Operators and Expressions
Variables, Operators and Expressions
Handling syntax and jargon
Java Variables
How to use variables
Making variables useful with operators
Declaring and Initializing the Sub' Hunter Variables
Errors, warnings, and bugs
Testing the game
Summary
4
Structuring Code with Java Methods
Structuring Code with Java Methods
Methods
Scope: Methods and Variables
Generating random numbers to deploy a sub
Testing the game
Summary
5
The Android Canvas Class – Drawing to the Screen
The Android Canvas Class – Drawing to the Screen
Understanding the Canvas class
Using the Canvas class
Canvas Demo app
Android Coordinate system
Drawing the Sub' Hunter graphics and text
Summary
6
Repeating Blocks of Code with Loops
Repeating Blocks of Code with Loops
Decisions, decisions
Keeping things tidy
More operators
Loops
Using for loops to draw the Sub' Hunter grid
Summary
7
Making Decisions with Java If, Else and Switch
Making Decisions with Java If, Else and Switch
If they come over the bridge shoot them
Combining different control flow blocks
Making sense of the screen touches
Final tasks
Running the game
Summary
8
Object-Oriented Programming
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
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
Running the game
Summary
10
Coding the Bat and Ball
Coding the Bat and Ball
The Ball Class
The Bat class
Coding the Bat input handling
Running the game
Summary
11
Collisions, Sound Effects and Supporting Different Versions of Android
Collisions, Sound Effects and Supporting Different Versions of Android
Handling collisions
Handling different versions of Android
The Soundpool class
Generating sound effects
Adding sound to the Pong game
Coding the collision detection and playing sounds
Playing the game
Summary
12
Handling Lots of Data with Arrays
Handling Lots of Data with Arrays
Planning the project
Starting the project
Reusing the Pong engine
Coding the Bullet class
Java Arrays
Simple array example mini-app
Getting dynamic with arrays
Entering the nth dimension with Arrays
Spawning an array of bullets
Summary
13
Bitmap Graphics and Measuring Time
Bitmap Graphics and Measuring Time
The Bob (player's) class
Running the game
Summary
14
The Stack, the Heap, and the Garbage Collector
The Stack, the Heap, and the Garbage Collector
Managing and understanding memory
Introduction to the Snake game
Getting started with the Snake game
Coding the game engine
Running the game
Summary
15
Android Localization -Hola!
Android Localization -Hola!
Making the snake game Spanish, English and German
Run the game in German or Spanish
Summary
16
Collections, Generics and Enumerations
Collections, Generics and Enumerations
Adding the graphics
Coding the apple
Using the apple
Using Arrays in the snake game
Arrays and ArrayLists are polymorphic
Enumerations
Summary
17
Manipulating Bitmaps and Coding the Snake class
Manipulating Bitmaps and Coding the Snake class
Rotating Bitmaps
Add the sound to the project
Coding the Snake class
Running the completed game
Summary
18
Introduction to Design Patterns and much more!
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
Listening with the Observer Pattern, Multitouch and Building a Particle System
The Observer pattern
Coding the Observer pattern in Scrolling Shooter
Coding a Multitouch UI controller and making it a listener
Running the game
Implementing a particle system explosion
Building a physics engine to get things moving
Running the game
Summary
20
More Patterns, a Scrolling Background and Building the Player's ship
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
Completing the Scrolling Shooter Game
Adding the alien's components
Spawning the Aliens
Running the game
Detecting collisions
Running the completed game
Summary
22
Exploring More Patterns and Planning the Platformer Project
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
Coding the component interfaces
Coding the other interfaces
Summary
23
The Singleton Pattern, Java HashMap, Storing Bitmaps Efficiently and Designing Levels
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
Sprite-sheet animations, Controllable Player and Parallax Scrolling Backgrounds
Animating sprite-sheets
Coding the Animator
Coding the player's components and transform
Coding a parallax background
Updating the levelManager, GameObjectFactory and GameObject
Running the game
Summary
25
Intelligent Platforms and Advanced Collision Detection
Intelligent Platforms and Advanced Collision Detection
Coding the moving platform component class
Update LevelManager and GameObjectFactory
Running the game
Coding the detectCollisions method: Part 1
Coding the detectCollisions method: Part 2
Running the game
Summary
26
What next?
What next?
Publishing
Using the assets from the book
Future learning
My other channels
Thanks
Index
Index

Summary so far

Take a look at these bullet points that describe everything we have discussed so far:

  • We will have component classes like MovementComponent, GraphicsComponent, SpawnComponent and InputComponent. These will be interfaces with no specific functionality.

  • There will be concrete classes that implement these interfaces like DiverMovement, PlayerMovement, StandardGraphics, BackgroundGraphics, PlayerInput etc.

  • We will have specification classes for each game object that specify the components that each object in the game will have. These specifications will also have extra details like size, speed, name and graphics file required for the desired appearance.

  • There will be a factory class that knows how to read the specification classes and assemble generic but internally different GameObject instances.

  • There will be a level class that will know which and how many of each type of GameObject is required and will order them from the factory class.

The net result will be that we will have...

Previous Section
End of Section 5
Next Section