[JAVA][Beginning Java 8 Games Development]

Chapter 8 ■ Creating Your Actor Engine: Design the Characters for Your Game and Define Their Capabilities
Notice that in addition to the .get() and .set() methods generated, for the boolean variables there is also an
additional .is() method that is generated instead of the .get() method. Since I already named the boolean flags using
the “is” preface, I am going to remove the second “Is” so that these “double is” methods are more readable. I am also
going to do this to the hasValu method, so that inquiring as to the boolean setting in the method call is more natural,
for instance, .hasValu(), isFlipV(), isBonus(), isFixed() or .isFlipH() for instance. I suggest that you perform the same
edits with your code, for readability purposes.
Now we are ready to create our Hero subclass, which will add another eleven attributes to the thirteen we have
created in the Actor class, bringing the total to an even two dozen. These additional eleven attributes held in the
Hero class will be used with movable sprites that can move around the screen (I like to call these motion sprites). Our
InvinciBagel character will be the primary Hero Actor object in the single-player version of our game, and for a future
multi-player version, this would include the InvinciBagel Hero Actor object and the Enemy Hero Actor object as well.
Creating a Hero Superclass: Motion Actor Attributes
Let’s create our public abstract Hero class next! This class will be the foundation for motion sprites that we will be
creating for the game during this book. Create your Hero.java class in NetBeans, and declare it as public abstract
class Hero extends Actor. Since we have done a lot of the “heavy lifting” in the Actor class, you will not have to
create an ImageView to hold the sprite Image assets, or the List ArrayList object loaded with a List object
filled with Image objects, or an SVGPath Shape object to hold the collision shape SVG polyline (or polygon) path data.
Since we don’t have to declare any primary attributes, as those are inherited from the Actor superclass, the first
thing we are going to do is to create a Hero() constructor method. This will contain your collision Shape data in a
String object, the sprite X, Y location, and the Image objects that will be loaded into the List ArrayList object.
After we create a basic Hero() constructor method, we will finish figuring out the other attributes (or variables) that
your motion sprites will need to contain, just like we did when we designed the Actor superclass.
Remember that you already have the spriteBound SVGPath Shape object, imageStates List ArrayList
object, SpriteFrames Image object and iX and iY variables constructed in the Actor class using Actor() method.
We will also need these to be in place in order to be able to code our Hero() constructor method. Since these are all
already in place, due to the java extends keyword in the Hero class declaration, all we have to do is use the super()
constructor method call and pass these variables from the Hero() constructor up to the Actor() constructor. This will
automatically pass these variables up into the Hero class for our use, using the Java super keyword.
Therefore, we have everything we need to be able to code our core Hero() constructor method, so let’s get into
that now. The Hero() constructor will take in the same number of complex parameters as the Actor() constructor.
These include your collision shape data, contained in the String object named SVGdata, an “initial placement” X and
Y location for the sprite, and a comma separated list of the Image objects (cels or frames) for the sprite, which I named
Image... spriteCels. This Image... designation, which needs to be at the end of your parameter list, because it is “open
ended,” means that the parameter list will pass in one or more Image objects. Your code will look like the following:
public void Hero(String SVGdata, double xLocation, double yLocation, Image... spriteCels) {
super(SVGdata, xLocation, yLocation, spriteCels);
}
By using super() to pass your core constructor work up to the Actor superclass Actor() constructor method, your
code that you wrote earlier, inside of the Actor() constructor, will create the spriteBound SVGPath Shape object using
the Java new keyword and the SVGPath Shape subclass, and will uses a SVGPath class .setContent() method in order
to load the SVGPath Shape object with your collision shape to be used with the sprite image states. The iX and iY
initial locations are set, and the imageStates List array is loaded with sprite Image objects, passed in from
the end of the parameter list.
www.it-ebooks.info
177