[JAVA][Beginning Java 8 Games Development]

Chapter 16 ■ Collision Detection: Creating SVG Polygons for the Game Actors and Writing Code to Detect Collision
A resulting Bounds object will be contained inside of the coordinate space of a Node object’s Parent object,
however, the Node object need not have a Parent (it can be the Scene Graph root of the Scene) in order to be able to
calculate the boundsInParent attribute. Just like the .getBoundsInLocal() method, this method does not take the Node
object’s visibility into account, so don’t make the mistake of thinking you can circumvent your collision detection
code by “hiding” your Actor Node, which, in our case, is an ImageView Node subclass named spriteFrame.
Since it computes changes to the boundsInLocal property, it is logical that the boundsInParent property will be
computed whenever the geometry of a Node changes, or when any transformations of that Node object occur. For
this very reason it would be a mistake to compute any of these values in a Node based on an expression that depends
upon this variable. For example, the X or Y variables of a Node object, or translateX, translateY shouldn’t be computed
using this boundsInParent property for the purpose of positioning the Node, since prior positioning data is included
in this property, and thus would create a circular reference (somewhat akin to the infamous infinite loop scenario).
Using Node Intersection: The .intersects(Bounds object) Method
Another important method in the JavaFX Scene Graph Node class where collision detection is concerned is the public
boolean intersects(Bounds localBounds) method. This method will return a true value if the Bounds object that
specifies the local coordinate space for the Node object that this method is being called “off of” intersects the Bounds
object passed into the method using the parameter, which is the Bounds object of the Node that you are trying to
determine intersection with. For instance, to determine if the ImageView Bounds that contains the InvinciBagel sprite
intersects the ImageView Bounds that contains one of the Prop sprites, we would use the following Java code format:
iBagel.spriteFrame.getBoundsInParent().intersects(object.getSpriteFrame().getBoundsInParent());
It is important to note that just like the .getBoundsInLocal() and .getBoundsInParent() methods, this method
also does not take the Node object’s visibility attribute into account. For this reason, an intersection test will be based
on geometry for the Node objects in question only, and for our ImageView spriteFrame Node objects, which would
be the geometry (dimensions) of their square (InvinciBagel) or rectangular (Prop) Image containers. The default
behavior of the Node class intersects(Bounds localBounds) function is to check and see if local coordinates for a
Bounds object that is passed into this method call intersects with the local Bounds coordinates of the Node that the
.intersects() method call is being called “off of.” Next, let’s take a closer look at the Shape superclass, and its .intersect()
method.
Using Shape Class Intersect: The .intersect( ) Method
Just like a Node class (object) has an intersection method called .intersects() that is used to determine when Node
objects intersect, the Shape class also has an intersection method, which you can use for Shape object intersection.
This method is called .intersect() (rather than intersects), so that these methods use different naming conventions.
This was probably done so developers won’t be quite as confused between Node.intersects() and Shape.intersect()
methods. We will be using both of these in our collision detection code later on in the chapter—first to detect when
an ImageView Node overlaps another ImageView Node, and then to do a Boolean intersection operation between our
SVG data collision polygons (SVGPath objects named spriteBounds within each Actor object).
The static method format for the Shape class’s .intersect() method takes two Shape objects in its parameter
list, and this method returns a new Shape object. The new Shape object that is created represents an intersection of
(between) two input shapes. As you can imagine, you can also use this method to do Boolean intersection generation
for your vector artwork if you are using the Shape class and its subclasses for this purpose. The format for the method
is static Shape intersect(Shape shape1, Shape shape2), and the way that we’re going to use it looks like this:
Shape shape = SVGPath.intersect(invinciBagel.iBagel.getSpriteBound(), object.getSpriteBound());
374
www.it-ebooks.info