Flash HitTest AS3 for Collision Detection, Flash Actionscript 3 Tutorial
In this tutorial, we’re going to learn how to create basic AS3 collision detection using the AS3 hitTestObject() method of the MovieClip class. Collision detection, in simplest terms, is a process of checking where items on your canvas intersect with each other. However! This isn’t just any tutorial – it’s a very special tutorial because we’re going to be using Flash CS5 and building from scratch, without any third-party frameworks or extensions! Let’s get started.
Introduction
Collision detection is a very important part of any game. It is used to detect when two objects collide with each other. There are many different ways to do collision detection. One way is to use a HitTest.
A HitTest is a function that checks to see if two objects are touching each other. If they are, then it returns true. Otherwise, it returns false.
HitTests are very simple to use. All you need to do is call the hitTestObject() function and pass in the two objects that you want to check. For example, if you wanted to check if a ball was touching a brick, you would write this:
ball.hitTestObject(brick);
If the ball was touching the brick, the function would return true. If it wasn’t touching the brick, the function would return false.
You can also use HitTests to check if an object is touching another object at a certain point. For example, let’s say you have a character that can move around on the screen. You can use a HitTest to check if the character is touching a platform at their feet.
To do this, you would write this: myCharacter.hitTestObject(platform); The function would check if they were touching the platform at their feet and return true or false.
You can also use HitTests to check if a point is within an object, instead of checking if the object is completely touching another object. For example, let’s say you have a character that can jump up through platforms.
You could check if the character was touching one of the platforms above them by using this function:myCharacter.hitTestPoint(posX, posY); The function would then return true or false based on whether or not he was touching it.
Setting up the movieclip
In this tutorial, we will learn how to set up a movieclip for collision detection in Flash.
First, create a new Flash document and add a movieclip to the stage. This movieclip will be the object that we will detect collisions with.
Next, open the actions panel and add the following code:
this.onEnterFrame = function() {
if (this.hitTest(_root._xmouse, _root._ymouse, true)) {
trace(‘hit!’);
} else {
trace(‘miss!’);
}
}
This code will check for collisions between the mouse and the movieclip on every frame. When a collision is detected, it will trace ‘hit!’. Otherwise, it will trace ‘miss!’.
Now try moving the mouse around on the stage. You should see ‘hit!’ or ‘miss!’ being traced depending on whether the mouse is touching the movieclip or not.
For the next part, we will add some more code to the mouse listener so that we can subtract the value of our sprite sheet from the current x and y coordinates.
Add this line immediately after the trace statement: this._x -= this.hitTest(_root._xmouse, _root._ymouse, true)Now try moving the mouse around on the stage again. You should see that your rocket moves along with it.
This means that when you hitTest()ed with a valid point, then you need to subtract one from your rocket’s x position. To make sure that you get a valid x coordinate we can use some if statements like this: if (this._x < 0) then …Followed by the same for y.
And if you look closely, this is exactly the same code we used to make sure that our rocket is moving in the right direction. You can see how if statements are a great way of checking if your code works fine or not!
And there you have it; we’re almost done with our game now! Just one more thing left, and then you’ll be able to hitTest() your player sprite as well. I’m gonna show you what that is first, though: if (this._x < 0) then and so forth if(this._x < LOW_PI) then replace LOW_PI with the actual value of LOW_PIOn the HighLow function.
And to do so, we’ve been using your trusty if statements. What we need to do then is to replace the and so forth if with a single ‘OR’ statement. And that’s exactly what it does. Click the green plus button at the bottom of the function, and go to the OR section of it. It looks like this: if (this._x 0) thenAnd because you have already learned how to use ‘OR’, I’ll show you in detail how it works: if (this ._x > 0) then Since this is true, we have already triggered the second condition, which in our case is false. This means that the code will never execute. And because of this, we are able to replace it with this new if statement: f ((this._x / 100) >= 20) then This code will only execute when our user’s X coordinate is greater than or equal to 20.
We can see that the result of our work was very efficient and easy to understand. We also reach a conclusion here, which is that the ‘OR’ statement can be used wherever you need it.
Testing for collisions and collision groups
1.1 Introduction
In this tutorial, we are going to learn how to detect collisions between different objects in Flash using ActionScript 3.0. We will also learn how to create different groups of objects and test for collisions between these groups. This is a very important concept to understand if you want to create games or other interactive applications in Flash.
1.2 Basic collision detection
The most basic way to detect a collision between two objects is to use the hitTestObject() method. This method takes two parameters, the first is the object that you want to test for a collision with and the second is a Boolean value that determines whether or not pixel-perfect collision detection should be used. Pixel-perfect collision detection is only necessary if the objects that you are testing for a collision are not rectangular in shape. For our purposes, we will set this value to false since we are only working with rectangular shapes.
Here is an example of how you would use the hitTestObject() method:
if(object1.hitTestObject(object2)){
trace(‘collision!’);
}else{
trace(‘no collision’);
}
AS3 hitTestObject() method of the MovieClip class
In this tutorial, we will learn how to use the hitTestObject() method of the MovieClip class to perform collision detection in Flash.
The hitTestObject() method returns a Boolean value, which indicates whether the two MovieClip objects are overlapping. We can use this method to check if two objects have collided.
To use this method, we need to pass in the other MovieClip object as a parameter. For example, if we have two MovieClip objects named mc1 and mc2, we can check if they are colliding by using the following code:
if (mc1.hitTestObject(mc2))
{
trace(‘Collision!’);
}
else
{
trace(‘No Collision’);
}
This code first checks if the mc1 MovieClip object has collided with the mc2 MovieClip object using the hitTestObject() method.
If this method returns a value of true, then we say that one or both of these objects have collided and set a trace statement to log this event to the Flash Debugger Console window.
As you can see, we are using Flash’s new trace statements which allow us to create easily readable logs of our actions in action scripts.
In order for our script to work, we will specify which MovieClip objects are colliding by increasing the clip’s number of “clips” (i.e., those frames that it is currently contained within). We do this by using the setClips() method. This does not actually change the number of clips on the movie clip (i.e., it doesn’t add or remove any), but rather enables us to specify a different number of clips for each instance of an object (using a lifespan, if you will).
We do this using the syntax setClips(n) which changes the nth instance of this object from its current value. In our case, we are setting the first two instances of a MovieClip to have 2 and 3 clips respectively.
Finally, we need to make sure that we use MovieClip objects instead of just plain old sprites when creating visible areas on our background movie clip. Since we want these keyframes to be displayed, we use the syntax setVisible(true) to indicate that they should be visible. We make sure that these keyframes are not displayed by calling setVisible(false) on all of the movie clip instances.
AS3 physics
In this tutorial, we’ll learn how to use the hittest method in ActionScript 3 to detect collisions between objects. This is a very useful technique to know, as it can be used for games, interactive applications, and more.
We’ll start by creating two simple shapes that we’ll use for our collision detection. Then, we’ll add some code so that when the shapes collide, they change color.
Finally, we’ll add some code so that the shapes bounce off of each other when they collide. This will give us a better understanding of how the hittest method works.
Conclusion
In this tutorial, we will be learning how to use the Flash HitTest AS library to detect collisions between objects in our scenes. We will also look at how to create a simple Flash action that will trigger when a collision is detected. By the end of this tutorial, you should have enough knowledge to start using the HitTest AS library in your own projects.