[JAVA][Beginning Java 8 Games Development]

Chapter 5 ■ An Introduction to Game Design: Concepts, Multimedia, and Using Scene Builder
High-Level Concept: Static vs. Dynamic
I want to start out with a high-level concept that touches on everything that I will be talking about in this chapter, from
the types of games you can create, to game optimization, to JavaFX Scene Builder and JavaFX Scene Graph. You took
a look at this concept back in Chapter 3, whether you realized it or not, while exploring the concept of a Java constant,
which is fixed, or static, and does not change, versus a Java variable, which is dynamic and changes in real time.
Similarly, a UI design in JavaFX Scene Graph can be static (fixed and immovable) or dynamic (animated, draggable, or
skinnable, meaning that you can change the UI look to suit your personal taste).
The reason these concepts are important in game design and development is that your game’s engine, which you
design to run or render your game, must constantly check on its dynamic portions to see if they have changed and
require a response (update a score, move a sprite position, play an animation frame, change the game piece’s state,
calculate collision detection, calculate physics, and so on). This checking (and the ensuing processing) on every frame
update (called a pulse in JavaFX; see Chapter 4), to make sure that all your variables, positions, states, animations,
collisions, physics, and the like are conforming to your Java game engine logic, can really add up, and, at some point,
the processor that is doing all this work can get overloaded, which can slow it down!
The result of this overloading of all the real-time, per-frame checking that enhances the dynamics of your game
(play) is that the frame rate at which your game is running will decrease. That’s right, like digital video and animation,
Java 8 games have frame rates, too, but Java 8 game frame rates are based upon the efficiency of your programming
logic. The lower the frame rate of your game, the less smooth the game play becomes, at least for dynamic, real-time
games, such as arcade games; how smoothly a game plays relates to how seamless (enjoyable) the user experience is
for the customer, the game player.
For this reason, the concept of static versus dynamic is very important to every aspect of game play design and
makes it easier to achieve a great user experience with certain types of games than with others. I will be discussing
different types of games later in the chapter (see the section “Types of Games: Puzzles, Board Games, Arcade Games,
Hybrids”), but, as you might imagine, board games are more static in nature, and arcade games are more dynamic.
That said, there are optimization approaches that can keep a game dynamic, that is, seem like a lot is going on, when,
from a processing point of view, what is really going on is quite manageable. This is one of the many tricks of game
design, which, when all is said and done, is about optimization.
One of the most significant static-versus-dynamic design issues in Android (Java) programming is UI design
using XML (static design) versus UI design using Java (dynamic design). The Android platform allows UI design to be
done using XML instead of Java so that nonprogrammers (designers) can do the front-end design for an application.
JavaFX allows exactly the same thing to be done using FXML. You have to create an FXML JavaFX application to do
this, as you saw in Chapter 2 (see Figure 2-4, right-hand side, third option, “JavaFX FXML Application”). Doing so will
add the javafx.fxml package and classes to the application, letting you design UIs, using FXML, and later having your
Java programming logic “inflate” them so that the design consists of JavaFX UI objects.
It is important to note that using FXML adds another layer, containing the FXML markup and its translation and
processing, to the application development and compilation process. I am going to demonstrate later in the chapter
how this is done, in case your design team wants to use FXML for the UI design work process, instead of Java (see the
section “JavaFX Scene Builder: Using FXML for UI Design”). I am doing this because I want to cover all the design
options in JavaFX, including FXML, to make sure that this book is complete in its coverage of what can be done using
Java 8 and JavaFX 8.0. At the end of the day, this is a Java 8 programming title, however, so my primary focus during
this book will be using Java 8, not FXML.
In any event, the point that I am making regarding using XML (or FXML) to create the UI design is that this
approach can be viewed as static, because the design is created beforehand, using XML, and is “inflated” at compile
time, using Java. Java inflation methods use the designer-provided FXML structure to create the scene graph, which
is filled with JavaFX UI (class) objects, based on the UI design structure (hierarchy) created using FXML. I will give
you an overview of how this works later in the chapter so that you have a handle on how this works (see the section
“JavaFX Scene Builder: Using FXML for UI Design”).
102
www.it-ebooks.info