[JAVA][Beginning Java 8 Games Development]

Chapter 13
Animating Your Action Figure States:
Setting the Image States Based on
KeyEvent Processing
Now that we have also organized your Java code into logical methods in the Bagel.java class, as well as making sure
that all of our Java code is standards compliant in Chapters 11 and 12, it is time to get into some more complicated
code structures that will animate our InvinciBagel character on the screen as the user moves the character. For
instance, if the character is traveling due East or due West (using only left or right keypresses, to travel in a straight
line), he should be running (alternating between the imageStates(1) and imageStates(2) List elements). If
the up key is also pressed, he should be leaping up in the direction of the left or right keypress, and if the down key is
pressed, he should be preparing to land in the direction of the left or right keypress.
We will also need to implement the Actor class’s isFlipH property or attribute, so that the character is facing the
right way based upon the direction he is traveling. Instead of using another image for that, we will use the JavaFX
capability to “flip” or “mirror” any image around its central Y axis (isFlipH) or around its central X axis (isFlipV). Once
a sprite animation state is combined with the movement code that you put into place in the previous chapter, you’ll be
amazed at how realistic this character will become, and we are still using only nine sprite state images (under 84KB of
total data footprint used for our new media assets so far).
We will do all of this character animation during this chapter using only Java code, and using only the JavaFX
AnimationTimer (GamePlayLoop) superclass. This way, we are optimizing the use of the JavaFX pulse engine for our
game by accessing the pulse event timing engine using only the javafx.animation package’s class that uses the least
amount of memory overhead. The AnimationTimer class is the most simple class, with no class variables, and only a
.handle() method to implement, and yet it is also the most powerful, because it lets you write all of your own code.
This approach allows us to write custom code to animate a character based on keys pressed and movement,
rather than triggering predefined Timeline objects based on KeyFrames (and their KeyValues) along that Timeline.
I am keeping it simple on the game engine side, and putting all of the complexity into our custom game play code.
This will save us a lot of headaches later on, trying to “synchronize” keyframe-based and timeline-based linear
animations, which puts us into a linear timeline-based paradigm, such as Flash uses. This 100% Java 8 coding
approach is certainly more difficult, from a Java coding perspective, but gives us an order of magnitude more power,
to achieve a seamless integration of event processing, screen movement, character animation, physics, and collision
detection. Setting up a multitude of prebuilt JavaFX Animation subclasses would presumably allow the same results
in the end, but the code would be less elegant, and probably much more difficult to build future versions of the game
play on top of.
All of our character state animation will be created using a .setImageState() method that will be called from
inside of the .update() method, so, we will continue to be organized in the movement and animation of our character.
www.it-ebooks.info
273