book

Android Game Programming: A Developer’s Guide

Name: Android Game Programming: A Developer’s Guide
ISBN: 9781787128583

by John Horton, Raul Portales

September 2016

Beginner to intermediate

1089 pages

23h 8m

English

Packt Publishing

Read now

Unlock full access

Android: Game Programming
Table of Contents
Android: Game Programming
Android: Game Programming
Credits
Preface
What this learning path covers
What you need for this learning path
Who this learning path is for
Reader feedback
Customer support
Downloading the example codeErrataPiracyQuestions

1. Module 1
1. Why Java, Android, and Games?
Is this book for me?If you just want to learn pure JavaIf Android is your focusWhere this book will take you
Why build games to learn to program?
Why Android and Java?
Android is the fastest evolving and growing OS everAndroid developers have great prospectsAndroid is open sourceJava is here to stayJava is not just for AndroidJava is fast and easy to useA summary of Java and Android
Setting up our development environment
Installing the JDKAndroid StudioInstalling Android Studio
Summary
2. Getting Started with Android
Our first game projectPreparing Android StudioBuilding the project
Exploring Android Studio
Using the Android Studio visual designer
Android UI typesTextViewLayout elementsImageView widgetsButtonViewUsing the sample codeMaking our game menu
Structuring our code for Android
Life cycle phases – what we need to knowLife cycle phases – what we need to doDividing our game into activities
Our first look at Java
Cleaning up our code
Building and installing our game
Emulators and devicesCreating an emulatorRunning the emulatorRunning our game on the emulatorBuilding our gameInstalling the setup to a deviceFuture projects
Self-test questions
Summary
3. Speaking Java – Your First Game
Java syntaxThe compilerMaking code clear with comments
Storing data and using it with variables
Types of variablesReference typesDeclarationInitializationChanging variables with operators
Expressing yourself in Java
Math game – asking a question
Creating the new game activityLaying out the game screen UICoding a question in JavaLinking our game from the main menu
Decisions in Java
More operatorsDecision 1 – If they come over the bridge, shoot themDecision 2 – Else, do thisSwitching to make decisions
Math game – getting and checking the answer
Self-test questions
Summary
4. Discovering Loops and Methods
Looping with loopsWhile loopsBreaking out of a loopThe continue keywordDo-while loopsFor loopsRandom numbers in Java
Methods
The structure of a methodModifierReturn typeName of a methodParametersGetting things done in the method bodyUsing methodsA working methodExploring method overloading
Enhancing our math game
Enhancing the UIThe new Java codeAmending GameActivityThe methodsThe setQuestion methodThe updateScoreAndLevel methodThe isCorrect methodCalling our new methods
Finishing touches
Going full screen and locking orientationAdding a custom image (instead of the Android icon)
Self-test questions
Summary
5. Gaming and Java Essentials
Java arrays – an array of variablesArrays are objectsA simple example of an arrayGetting dynamic with arraysDynamic array exampleEntering the nth dimension with arraysAn example of a multidimensional arrayArray-out-of-bounds exceptions
Timing with threads
A simple thread timer example with the Handler class
Beeps n buzzes – Android sound
Creating sound FXPlaying sounds in Android
Life after destruction – persistence
An example of persistence
The memory game
Phase 1 – the UI and the basicsPhase 2 – preparing our variables and presenting the patternPhase 3 – the player's responsePhase 4 – preserving the high scoreAnimating our gameUI animation in AndroidPhase 5 – animating the UI
Self-test questions
Summary
6. OOP – Using Other People's Hard Work
What is OOP?Why do it like this?
Our first class and first object
Basic classesMore things we can do with our first class
Encapsulation
Controlling the use of classes with access modifiersClass access in a nutshellControlling the use of variables with access modifiersVariable access in a nutshellMethods have access modifiers tooMethod access in a nutshellAccessing private variables with the getter and setter methodsSetting up our objects with constructorsVariables revisitedThe stack and the heapA quick break to throw out the trashAccess, scope, this, static, and constructors demoA quick summary on stack and heap
Inheritance
An example of inheritance
Polymorphism
Abstract classesInterfaces
More about OOP and classes
Inner classes
Self-test questions
Summary
7. Retro Squash Game
Drawing with Android CanvasThe Android coordinate systemAnimating our pixelsGetting started with Canvas and Paint
Android Canvas demo app
Detecting touches on the screen
Preparing to make the retro squash game
The design of the gameThe UIPhysicsThe structure of the code
The four implementation phases in detail
Phase 1 – MainActivity and onCreatePhase 1 code explainedPhase 2 – SquashCourtView part 1Phase 2 code explainedPhase 3 – SquashCourtView part 2Phase 3 code explainedPhase 4 – Remaining lifecycle methodsGood object-oriented design
Self-test questions
Summary
8. The Snake Game
Game design
The coordinate system
Keeping track of the snake segmentsDetecting collisionsDrawing the snake
The code structure
MainActivityGameActivityTidying up onCreate
Animation, sprite sheets, and the Snake home screen
Animating with sprite sheetsImplementing the Snake home screen
Implementing the Snake game activity
Enhancing the game
Self-test questions
Summary
9. Making Your Game the Next Big Thing
How to publish your app
Marketing your app
Adding leaderboards and achievements
Planning the Snake achievementsStep-by-step leaderboards and achievementsInstalling the Google Play Services API on your PCConfiguring the Google Play developer consoleImplementing the leaderboard in the Google Play developer consoleImplementing the achievements in the Google Play developer consoleSetting up the Snake project ready for implementationImplementing the player's sign-in, achievements, and leaderboard buttonsImplementing the leaderboards in codeImplementing the achievements in codeUploading the updated Snake game to Google Play
What next?
Getting a programmer's jobBuilding bigger and better games
Self-test questions
Summary
A. Self-test Questions and Answers
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
2. Module 2
1. Player 1 UP
A closer look at the gamesTappy DefenderTough retro platformerAsteroids simulator
Setting up your development environment
Installing the JDKInstalling Android Studio
Summary
2. Tappy Defender – First Step
Planning the first gameBackstoryThe game mechanicsRules for the gameThe designControlModelViewDesign pattern reality checkThe game code structureThe Android Activity lifecycleThe Android Studio file structure
Building the home screen
Creating the projectWhat we didBuilding the home screen UIWhat we didCoding the functionalityCreating GameActivityWhat we didConfiguring the AndroidManifest.xml fileWhat we did
Coding the game loop
Building the viewCreating a new class for the viewWhat we didStructuring the class codeThe game activity
The PlayerShip object
Drawing the scene
Plotting and drawingDrawing PlayerShipThe Canvas and Paint objectsControlling the frame rate
Deploying the game
Debugging on an Android device
Summary
3. Tappy Defender – Taking Flight
Controlling the spaceshipDetecting touchesAdding boosters to the spaceshipDetecting the screen resolution
Building the enemies
Designing the enemySpawning the enemyMaking the enemy think
The thrill of flight – scrolling the background
Things that go bump – collision detection
Collision detection optionsRectangle intersectionRadius overlappingThe crossing number algorithmOptimizationsMultiple hitboxesNeighbor checkingBest options for Tappy Defender
Summary
4. Tappy Defender – Going Home
Displaying a HUD
Implementing the rules
Ending the game
Restarting the game
Adding sound FX
Generating the FXThe SoundPool classCoding the sound FX
Adding persistence
Iteration
Multiple different enemy graphicsAn exercise in balanceFormat timeHandle the back button
The finished game
Summary
5. Platformer – Upgrading the Game Engine
The gameThe backstoryThe game mechanicsRules for the game
Upgrading the game engine
The platform activityLocking the layout to landscapeThe PlatformView classThe basic structure of PlatformViewThe GameObject classThe view through a viewportCreating the levelsThe enhanced update methodThe enhanced draw method
Summary
6. Platformer – Bob, Beeps, and Bumps
The SoundManager class
Introducing Bob
Multiphase collision detection
Player input
Animating Bob
Summary
7. Platformer – Guns, Life, Money, and the Enemy
Ready aim firePickupsThe droneThe guard
Summary
8. Platformer – Putting It All Together
Bullet collision detection
Adding some fire tiles
Eye candy
The new platform tilesThe new scenery objectsScrolling parallax backgroundsPause menu with moveable viewportLevels and game rulesTraveling between levelsThe level designsThe caveThe cityThe forestThe mountainsThe HUD
Summary
9. Asteroids at 60 FPS with OpenGL ES 2
Asteroids simulatorThe game controlsRules for the game
Introducing OpenGL ES 2
Why use it and how does it work?What is neat about Version 2?How we will use OpenGL ES 2?
Preparing OpenGL ES 2
Locking the layout to landscapeActivityThe viewA class to manage our gameManaging simple shadersThe game's main loop – the renderer
Building an OpenGL-friendly, GameObject super class
The spaceship
Drawing at 60 + FPS
Summary
10. Move and Draw with OpenGL ES 2
Drawing a static game border
Twinkling stars
Bringing the spaceship to life
Rapid fire bullets
Reusing existing classes
Adding the SoundManager classAdding the InputController class
Drawing and moving the asteroids
Scores and the HUD
Adding control buttonsTally iconsLife iconsDeclaring, initializing, and drawing the HUD objects
Summary
11. Things That Go Bump – Part II
Planning for collision detectionColliding with the borderThe first phase of border collision detectionColliding with an asteroidThe crossing numberThe first phase and overview of asteroid collision detectionThe CollisionPackage classAdding collision packages to the objects and making them accessibleAdding a collision package to the Bullet classAdding a collision package to the SpaceShip classAdding a collision package to the Asteroid classThe CD class outlineImplementing radius overlapping for asteroids and shipsImplementing rectangle intersection for the border
Performing the checks
Helper methodsDestroying a shipDestroying an asteroidTesting for collisions in update()
Precise collision detection with the border
Precise collision detection with an asteroid
Finishing touches
Summary
3. Module 3
1. Setting Up the Project
The right tool for the right gameDo you want to use 3D?Do you want to use physics?Do you want to use Java?Pros of building games with the Android SDKCons of building games with the Android SDKI want the Android SDK!
The project – YASS (Yet Another Space Shooter)
Activities and FragmentsProject setupCreating the stub projectCleaning upChoosing an orientationDealing with aspect ratios
Game architecture
GameEngine and GameObjectsStarting a gameStopping a gameManaging game objectsUpdateThreadDrawThreadUser input
Putting everything together
Moving forward with the example
Handling the back keyHonoring the lifecycleUsing as much screen as we canBefore Android 4.4 – almost fullscreenAndroid 4.4 and beyond – immersive modePutting fullscreen together
Good practices for game developers
Object poolsAvoiding enhanced loop syntax in listsPrecreating objectsAccessing variables directlyBeing careful with floating pointsPerformance myths – avoid interfaces
Summary
2. Managing User Input
The InputController base classThe Player objectDisplaying a spaceshipFiring bulletsThe Bullet game object
The most basic virtual keypad
Limitations and problems
Creating a virtual joystick
General considerations and improvements
Physical controllers
Handling MotionEventsHandling KeyEventsDetecting gamepads
Sensors and InputControllers
Selecting control modes
Summary
3. Into the Draw Thread
Using GameViewThe GameView interfaceStandardGameViewSurfaceGameViewUpdating GameEngineUpdating the game layout
Improving DrawThread
Sprites
Updating the spaceship and bullets
Adding a frames-per-second (fps) counter
Spawning enemies – the GameController
Procedural/randomDeterministic/staticHybrid approachOur approachThe asteroidsMore on the transformation matrix
Occlusion culling
Parallax backgrounds
Multiple backgrounds
Layers
Summary
4. Collision Detection
Detecting collisionsWho can collide?Updating GameEngineHandling collisions
Rectangular bodies
Adding visual feedbackPros and cons
Circular bodies
Adding visual feedbackPros and cons
Mixed collision detection
Adding visual feedbackOther options for shapesOptimizationSpatial partitioning and QuadTreeDuplicated collisions
Summary
5. Particle Systems
General conceptsParticlesParticleSystemInitializersModifiersComposite GameObjects and GameEngine
Making good particle systems
One shot
Asteroid explosionsSpaceship explosions
Emitters
Asteroid trailsThe spaceship's engine
Summary
6. Sound FX and Music
SoundManager
Sound FX
How to create sound FXsGameEventsUsing SoundPool
Playing music
Obtaining musicMediaPlayerMusic and Activity life cycle
Enabling and disabling music and sound FX
Updating MainMenuFragmentUpdating SoundManager
Disabling system sounds
Summary
7. Menus and Dialogs
Custom fonts
Working with backgrounds
The power of XML drawablesState list drawablesState lists colorsShape drawables
The GameFragment
Adding a scoreAdding lives
Custom dialogs
BaseCustomDialogQuit dialogPause dialogGame Over dialogOther dialogs
Designing for multiple screen sizes
Summary
8. The Animation Framework
Updating BaseFragment
AnimationDrawable
Animated spritesAnimating viewsXML versus codeInterpolators
View animation
Animating dialogsDelaying the action in the dialogs to onDismissedPulsating buttons
Property animation
ViewPropertyAnimatorMoving a spaceship aroundAnimating the main menu
Summary
9. Integrating Google Play Services
Setting up the developer console
Setting up the code
Achievements
ArchitectureUnlocking achievements
Leaderboards
Opening the Play Games UI
Other features of Google Play services
EventsQuestsGiftsSaved gamesMultiplayer games
Summary
10. To the Big Screen
Project configuration
Testing for Android TV
Declaring a TV Activity
Providing a home screen banner
Declaring it as a game
Declaring Leanback supportDeclaring touchscreen capability as not required
Reviewing the manifest
Showing controller instructions
Dealing with overscanController-based navigationDialogs and controllers
Beyond this book
Summary
A. API Levels for Android Versions
A. Bibliography
Index

Content preview from Android Game Programming: A Developer’s Guide

Preparing to make the retro squash game

Now we are ready to discuss the making of our next game. We actually know everything we need to. We just need to think about how to use the different techniques we have learned.

Let's first look at exactly what we want to achieve so that we have something to aim for.

The design of the game

Let's look at a screenshot of the game as a good starting point. When you design your own games, drawing sketches of the in-game objects and mechanics of the game will be an invaluable part of the design process. Here, we can cheat a bit by taking a look at the end result.

The UI

Starting from the top, we have Score. Every time ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781787128583

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills