Foundation Game Design with ActionScript 3.0, Second Edition (97 page)

Figure 10-6.
The wand rotates around the center of the fairy and always points in the direction of the mouse.

To make this work, you first have to find the angle between the mouse and the center of the fairy. The code does this using the
Math.atan2
function. Here's the code that works out the angle between the mouse and the fairy:

AS3.0 has a specialized function called
Math.atan2
function that tells you the angle of rotation of an object. You use it by supplying it with any vx or vy values that describe a distance vector between two objects. (Refer back to
Chapter 6
for a refresher on what a distance vector is and how to find it.) In this example, the distance vector is described by the difference between the fairy and the mouse's position on the stage:

Very importantly, when you use
Math.atan2
, make sure that
vy
value is the first argument, and the
vx
value the second, like so:

Math.atan2
returns a number in
radians.
Unfortunately, this is not useful for rotating sprite objects. You need to convert this number to
degrees,
which is the type of value expected by the rotation property.

To convert radians to degrees, you can use a simple calculation: multiply the value in radians by 180 divided by pi (3.14). AS3.0 has a built-in function called
Math.PI
that returns the value of pi, just to make things easier for you. Here's what the final line of code might look like:

This gives you a rounded-off value in degrees that you can apply to the
rotation
property of any sprite.

I decided that I wanted the wand to rotate around the fairy within a 50-pixel radius. A variable called
radius
defines this distance.

A negative value pushes the wand away from the center of the fairy, which happens to be the direction in which the mouse will be pointing.

The wand's x and y position is found by multiplying the radius by angle ratios obtained using two specialized functions:
Math.cos
and
Math.sin
. They both take the
_angle
value as arguments. The result is then added to the fairy's x and y position so that the wand moves with the fairy.

Math.cos
and
Math.sin
functions are two specialized trigonometry functions that return the ratio of two sides of the triangle formed by the measurement of the angle. The result is exactly as you see it on the stage.

Each time you click the left mouse button, the code calls the
mouseDownHandler
that creates and fires stars in whatever direction the fairy's wand is pointing.

Each star is created and added to the stage using the
GameObject
, class, in exactly the same way that the code created the
_fairy
and
_wand
objects.

When it's created, the star's x and y positions are the same as the wand's.

Each star then needs a unique velocity that will make it move away from the fairy in the direction that the mouse is pointing. To find this, we can use the same
_angle
value we're using to rotate the wand and feed it to the
Math.cos
and
Math.sin
values. If we multiply those results by −7, it will make the star move away from the center of the fairy at seven pixels per frame.

The star is then pushed into the
_stars
array so that we can move and manage it along with all the other stars in the game.

A
for
loop in the
enterFrameHandler
is what makes the stars move and checks the stage boundaries.

The loop first makes each star in the
_stars
array move in the correct direction by adding its vx and vy values that we calculated in the
mouseDownHandler
to its x and y positions.

It then checks to see whether the star has crossed the stage boundaries.

If it has, it removes the star. First, it removes it from the stage and sets its value to
null
.

It then uses the
splice
method to delete the star from the
_stars
array.

The code then has to reduce the loop counter by one to compensate for the star that was just cut out of the array.

If you don't do this, it throws the counter off by one, and the loop will skip the next item.

What's new here is using
splice
to remove an element from an array.
splice
uses two arguments: the first is the index number of the element to remove, and the second is the number of elements it should remove from that point onward.

In this case, you want to remove the current star, which is at index number
i
. If the loop is in its third repetition, that would be element number
2
. (Remember, array elements are numbered starting at zero.)

In the second argument,
l
is the number of elements to remove. In this case, you want to remove only one element.

What
splice
does in this program is to remove the star from the array so the program no longer has to move it or check it for stage boundaries. If you don't splice it out of the array, the array will just get bigger and bigger, and the program will start to generate errors because it would contain references to star objects that have already been removed from the stage with
removeChild
.

splice
is a very versatile method to use with arrays, and you'll certainly find many occasions when it will help you manage game objects.

This little bit of code for firing projectiles is one of the most important you need to know as a game designer. If any of your game objects need to fire bullets, come back to this section in the chapter and adapt this code to your game. It's a game programming classic.

We've taken a detailed look at many different types of player control systems in this book, but it hasn't been exhaustive. To make the widest variety of games possible, there are a few more player control schemes that you'll likely want to implement, such as the following:

• A mouse-controlled platform game character
  
• A keyboard-controlled spaceship
  
• A car for an overhead driving game
  
• A tank that can rotate and fire bullets from a turret
  

You'll find working examples and detailed explanations of how all these systems work in the bonus chapter “Advanced Player Control Systems,” which you'll find in the book's download package.
Figure 10-7
shows the kinds of game objects you'll learn how to make.

Figure 10-7.
Advanced player control systems

We've taken a good look at player control systems, but what about your game enemies? They're fun to make and easy to program. As you'll see in this next section, just a few simple techniques and a bit of run-of-the-mill logic is all you need to build some surprisingly sophisticated enemy artificial intelligence (AI) systems.

You already know how to make an object follow the mouse, and that basic skill is at the heart of an AI system that you can modify for use in a wide variety of game situations. All you need to do is mix and match some of the techniques you already know, and you can design enemies that do the following:

• Follow the player
  
• Run away from the player
  
• Aim and fire bullets at the player
  

Let's find out how.

Open the
Follow
project folder and run the SWF. You'll see that Killer Bee follows and rotates toward the mouse if it's within a 200-pixel range.
Figure 10-8
illustrates what you will see. After it reaches the mouse, it circles around it with very bee-like persistence.

Figure 10-8.
The bee rotates toward the mouse and follows it around the stage.

The bee is created using the general
GameObject
class we used in the ButtonFairy project. Here's the
Follow
application class that creates the effect: