Game Development Reference
In-Depth Information
chapter we'll have a clean, empty environment filled with solid and working
power-ups we can collect.
Chapter 5
is about refining the Player character and the Player input to work
consistently across multiple platforms, from desktop systems to mobile devices.
Here we'll develop a customized First Person Controller based on the default
Unity Controller, which works on Windows, Mac, Linux, Android, iOS, and
Windows Phone. We'll also examine mathematical ideas, such as
sine waves
and
curves
to program a customizable
head-bob effect
to the first-person
camera. That is, to simulate the natural effect of head movement, we'll make the
camera bob up and down seamlessly as the Player moves around in the world.
And we'll also work with Mecanim to create a death animation in which the
camera falls to the ground.
Chapter 6
is where we give the player some fire power. Specifically, we'll code
the ability to attack and inflict damage with Weapons, both the fists and pistol
weapons. In this chapter, we'll look deeper at class inheritance and at concepts
like
virtual functions
and
polymorphism
. In addition, we'll also see how to create
animated sprites for creating weapon animations (such as gun fire) using
timing
functions and
coroutines
.
Chapter 7
throws our three evil enemies into the mix—namely Drones, Tough
Guys, and Mr. Big Cheese. Building these guys will lead us into a veritable
coding extravaganza. With these, we'll code enemies that can take and inflict
damage, and behave with artificial intelligence that integrates well with the Unity
Pathfinding and Navigation system. Here, we'll explore concepts such as
Finite
State Machines
(FSMs), so enemies can make informed decisions and change
their behavior, as well as how to program with
NavMeshes
and
NavMesh Agents
,
allowing enemies to find their way intelligently about the level, while avoiding
physical obstacles along the way.
Chapter 8
delivers us into the troublesome world of GUIs (graphical user
interfaces), where we'll see the limitations of the Unity GUI system and the
benefits of coding our own. Further, we'll consider concepts such as
resolution
and
aspect ratio
, as well as
anchoring
and
hierarchies
, to code fixed-sized
interfaces that look good and act predictably at various screen sizes.
Chapter 9
explains how to code a load-and-save game system, allowing the
user to save his or her gaming session to persistent storage, from where it can
be restored without data loss at any later time. This chapter will explore XML
files, the .NET Framework classes, and data serialization.
Chapter 10
completes our work, leaving us with a 100%-working FPS game.
There will no doubt be room for improvement, of course. But in this chapter,
we'll recap over all the concepts we've seen throughout the topic, thinking about
how we might apply them in other contexts and to other projects. In addition,
this chapter will crystalize or condense many of those concepts into bite-size
and easy-to-remember chunks, which will make the chapter especially useful
as both a pseudo-appendix for this topic, as well as a more general coding
reference.
