Heroes & Villains – A Checklist Aside

In Half Certainly one of this game-building tutorial, we created a hero ship and a bullet and programmed the 2 to work in tandem. The ship may be steered through the arrow keys, and the house bar launches the bullet from the ship’s location.

Article Continues Beneath

Now it’s time to begin turning this experiment from a primitive surroundings simulator to an actual sport.

This sport, like all others, includes battle, guidelines, and the potential for loss in addition to achieve.  Heroes alone make for boring video games.  We want a villain.

Now we’ll add a rock to the combo – sure, only one for now – and assign it the next script:

onClipEvent (enterFrame) {
_x += deltax;
_y += deltay;
if (_x<0) {
_x = centerx*2;
} else if (_x>(centerx*2)) {
_x = 0;
if (_y<0) {
_y = centery*2;
} else if (_y>(centery*2)) {
_y = 0;
if (this.hitTest(_root.bullet._x, _root.bullet._y, true)) {
perform findRandomPosition () {
// We’re going to make use of some easy trig to place
// the rock away from the middle of the display screen
// We outlined the centerx and centery when this clip first loaded
// (Down beneath within the onClipEvent(load) occasion handler)
radius = 190+Math.random()*75;
// This creates a random quantity between 190 and 265
// Which controls how removed from the middle of the
// display screen the rock will seem
// We don’t need it smack within the center, the place the ship is.
angle = Math.random()*(2*Math.PI);
// this generates an angle between 0 and a couple of * PI
// --in different phrases, someplace in a full circle
_x = centerx+Math.cos(angle)*radius;
// The x place of the rock is the x part
// of its angle, the cosine, multiplied by the radius
_y = centery+Math.sin(angle)*radius;
// The y place of the rock is the y part
// of its angle, the sine, multiplied by the radius
deltax = (Math.random()*10)-5;
// Little formulation to calculate a random quantity from -5 to five
deltay = (Math.random()*10)-5;
perform destroyRock () {
_root.bullet._x = -100;
_root.bullet._y = -100;
_root.bullet.deltax = 0;
_root.bullet.deltay = 0;
onClipEvent (load) {
// This will get known as when this rock first seems
centerx = 275;
centery = 200;
radius = 190+Math.random()*75;
angle = Math.random()*(2*Math.PI);
_x = centerx+Math.cos(angle)*radius;
_y = centery+Math.sin(angle)*radius;
deltax = (Math.random()*10)-5;
deltay = (Math.random()*10)-5;

How do you create a rock?  Properly, in case you’ve acquired my work ethic, you draw a gray circle and choose it and hit F8, then you definately hit Management-i (Command-i for Mac) and kind “rock” (with out the quotes, sure).  Create a brand new layer, reduce and paste this rock onto it, and rename it “rock.” Ah.  Adequate for presidency work, as they are saying.

In actual fact, whereas we’re at it, let’s make certain all our layers are named appropriately.  There ought to be a layer named “ship” that comprises the ship – and solely the ship.  There ought to be a layer named “bullet” that comprises the bullet – and solely the bullet.  There ought to be a layer named “evil urges” that comprises – okay, rename it “actions” and depart it empty for a second.

Bear in mind how I mentioned that utilizing onClipEvent() scripts connected to our film clips freed us from the tyranny of timeline-based scripts?  I meant each phrase of it.  However that doesn’t imply the film ain’t gonna play.  No, it’s going to play, all proper – and it’ll loop proper again to the start when it reaches the top of the frames in the principle timeline.

Is that this a catastrophe? Properly, no. Not but, it isn’t.  However will probably be as soon as we begin doing fancy stuff, so let’s put an empty keyframe on body 14 of the “actions?`; layer and convey up the script window.  Sort in a body script that claims


…and I’ll provide you with a shiny new nickel in case you can’t inform me precisely what that does.

So add the script to the rock by choosing it after which opening the script window.  Word the opposite onClipEvent() script I’ve added to enhance the acquainted onClipEvent(enterFrame) script.

OnClipEvent(load) is an occasion that will get known as when a clip seems within the rating – in different phrases, when the principle timeline reaches part of the film that comprises this clip. In order for you this perform to fireplace solely as soon as within the film, make certain the film clip doesn’t seem and disappear from the principle timeline.

On this case, the (load) script known as as soon as, and it randomizes the situation of the rock in addition to its x and y speeds. Consider it as a particular perform that will get known as robotically when the film clip seems in your major timeline.

Additionally please observe that this code to discover a random location for the rock exists up within the onClipEvent(enterFrame) script as nicely –  inside a perform named findRandomPosition().  (It’s factor to make use of very expressive names for variables and features, by the way in which. You’ll be glad later.  Anybody taking a look at your code might be glad too. As Flaubert mentioned: “Be common and orderly in your life, like a bourgeois, so you might be violent and authentic in your work.”)

Properly, the query involves thoughts:  If we’ve acquired a perform that’ll discover a good, random location for us, why don’t we simply name it from the onClipEvent(load) handler?

Uh… that’s an excellent query.  As a result of it doesn’t work.  Ethical: Calling features from a (load) handler isn’t a good suggestion.

So I’ll clarify actually shortly what the (load) handler is doing, after which I’ll clarify the code in findRandomLocation(), as a result of that’s the identical algorithm that the (load) handler makes use of to place the rock.

The more durable they code, the more durable they fall#section6

What’s the (load) handler doing? It’s declaring the variables centerx and centery, that are the horizontal and vertical heart factors of the display screen, respectively. The film clip will keep in mind these variables for its complete life, which is good and saves us work.

It additionally signifies that if we ever enlarge the dimensions of the stage, all we’ve to do is change these variables within the (load) handler and the rock will be capable of deal with the change completely.

In actual fact, take a sneak peek on the wraparound code for the rock. You’ll see that it not checks to see if the rock’s x worth is bigger than 570 (the best fringe of the display screen) or if its y worth is bigger than 400 (the underside fringe of the display screen).

As a substitute, it checks the rock’s x and y positions based mostly on centerx and centery.  If centerx is 275, then the best edge should be centerx*2.  Properly, in truth, that is round reasoning, based mostly on the truth that we assigned centerx the worth of 275 just because we knew that was midway throughout the display screen. However this will even enable us to vary the dimensions of the stage after which merely change centerx and centery, which is an entire lot higher than scouring the code for references to 275 or 200 or 570 or 400.

That’s what programmers imply by avoiding the laborious coding of values.  Merely put: if there’s a quantity that you simply’re going to confer with repeatedly, and it’s probably going to vary in some unspecified time in the future sooner or later, then assign it to a variable and all the time use that variable for the remainder of your film.  Makes life simpler.

In actual fact, in case you have been spiritual about it, you may transfer your centerx and centery variables to the principle timeline and confer with them each time you want them.  However for now, we’ll let it lie.

Shot with hs personal gun#section7

Our code to wrap the rock across the edges of the display screen –  nicely, actually to pop it throughout to the opposite facet when it will get too close to the sting –  is now fairly clear and versatile, so why not apply it to the bullet and the ship as nicely?  In fact, this implies we even have to make use of an onClipEvent(load) script to set centerx and centery for every of these film clips, however that’s a second’s work.

The one catch is that this: that code must be altered for the bullet. As we’ll see additional alongside, there are occasions once we undoubtedly need the bullet to remain off display screen –  specifically, when it’s not transferring.  So I’ve put the bullet’s wraparound code inside a fast conditional take a look at:

if ((deltax != 0) and (deltay != 0)) {
//wraparound code goes right here

This principally makes certain that the code solely executes if the bullet is sitting nonetheless.  The != operator means “doesn’t equal” and is a well-known a part of C-based syntax, so JavaScript coders will realize it nicely.

This type of conditional will seem many locations on this tutorial.  In actual fact, state-based choices are key to sport programming in any language.  Is the bullet alleged to be transferring? Then transfer it.  Is the rock hittable? Then test to see if it’s being hit.

Typically one of the simplest ways to maintain observe of an object’s present state is to create a particular variable to carry it –  say, “state”  –  and alter it when the article modifications state (e.g., when a bullet is launched, change its state to “flying”).

However on this case, for the reason that bullet solely has two states (transferring and nonetheless), checking if deltax and deltay are zero will do the trick.

Random acts of positioning#section8

Let’s return to the rock’s script.  I’ve commented the code fairly closely, however because it includes some math, there’s all the time room for dilation.

Listed below are the center of it:

centerx = 275;
centery = 200;radius = 130+Math.random()*70;angle = Math.random()*(2*Math.PI);_x = centerx+Math.cos(angle)*radius;_y = centery+Math.sin(angle)*radius;deltax = (Math.random()*10)-5;deltay = (Math.random()*10)-5;

We would like the rock to seem randomly, certain.  However we don’t need it to seem smack on prime of the ship.  So let’s do it the basic arcade manner:  by positioning the rock randomly across the fringe of the display screen.

Let’s fake the rock goes to be someplace on the perimeter of an imaginary circle.  The circle goes to be centered across the center of the display screen, and its dimension goes to be considerably random. We would like it to be greater than 130 (or else its edge can be fairly near the middle) and fewer than, say, 200 (which might put its edge dangerously near the sting of the display screen, and we would like the rock onscreen, in any case).

So we set our radius to a random quantity between 130 and 200.  After which we simply decide a random angle to discover a level someplace on the circle’s perimeter.  By setting a variable named “radius“ to a random quantity between 0 and a couple of*pi, we do exactly that.  (Bear in mind, trig features use radians, not levels – if life have been excellent, we’d use a quantity between 0 and 360 to point levels. Then once more, if life have been excellent, we’d additionally fly to work on hydrogen-powered hover scooters.)

We’ve acquired a radius and a pleasant, random angle.  Now let’s use trig to transform these values into x and y coordinates our rock can use.

To search out the x place, you multiply the radius by the cosine of the angle.  To search out the y place, you multiply the radius by the sine of the angle.  Easy!

Ah, we’re not finished but.  We will’t transfer a ship to that place but, as a result of we forgot that our imaginary circle is meant to begin on the heart of the display screen. However our easy trig calculations will assume it’s at 0,0, which signifies that the percentages are fairly good it’ll place our rock off to the left someplace or off the highest.

We repair this by including centerx to the x place that our circle trick gave us, and including centery to the y place it gave us.

Astutely, you would possibly nicely be asking:  “However your radius is about to a random quantity between 130 and 200.  Why 130 because the minimal, and why 200 as the utmost?  If the display screen modifications dimension, received’t which have to vary as nicely?  Isn’t this hard-coding?”

Properly, sure.  The easiest way to calculate a random radius can be a formulation based mostly upon centerx and centery (whichever is smallest).  For the sake of readability I’ve prevented opening that may of worms right here, however please be happy to attempt your hand at it.

When dangerous issues occur to good rocks#section10

Along with the (load) script, there’s additionally a perform known as destroyRock().  It will get known as elsewhere on this (enterFrame) script, however in reality it might be known as by any script wherever on this complete film file.  If we wished our ship to have the ability to destroy this rock, we might add…


…to our ship’s script, and the rock would begin executing the code inside its destroyRock() perform.

In actual fact, later we’ll be calling the rock’s findRandomPosition() perform from the ship.  However let’s not get forward of ourselves.

As a substitute, let’s give attention to destroyRock().  What does it do?

Two issues: it tells the bullet to go take a powder, and it tells the rock to randomly place itself someplace onscreen utilizing the identical code that was used within the (load) handler.

Right here’s the code for eliminating the bullet:

_root.bullet._x = -100;
_root.bullet._y = -100;

Or, in different phrases, get off this display screen and go to your room.

_root.bullet.deltax = 0;
_root.bullet.deltay = 0;

And don’t go wherever.

Is the rock being hit?  That’s the query we should ask earlier than calling destroyRock(), in any case.

So let’s take a look at the code that checks to see if the rock is being hit by the bullet.  That is the code that can name destroyRock() if, in truth, it determines that such brutality is happening.

if (this.hitTest(_root.bullet._x, _root.bullet._y, true)) {

Appears fairly easy, eh?  The hitTest() perform is a phenomenal addition to Flash ActionScript, and actually it may possibly work one in all two methods.  The way in which I’ve used, we ship three arguments to the perform (a elaborate manner of claiming I’ve put three items of information between the parentheses): I ship an x, a y, and a particular form of fixed known as a Boolean true to the hitTest perform.  (You don’t need to know a lot about Boolean constants and variables to make use of them; they’re basically a prettied-up manner of claiming 0 and 1, they usually’re good to make use of for any scenario that wants a real or false reply.  On this case, it tells the Flash interpreter that I do certainly wish to have the form flag set.)

The form flag permits us entry to some highly effective collision detection that Flash 4 merely couldn’t give us.  Setting the form flag to true tells the Flash engine that we would like it to look fastidiously to test if that x and y coordinate are hitting precise pixel information contained in the rock film clip and are usually not in truth on prime of empty house.  That is extra rigorous than merely testing to see if the pixel falls contained in the bounding field of the rock, which could register as a success even when the pixel have been passing intently by.  Once you’ve acquired sprites that don’t occur to be box-shaped, and you actually desire a larger stage of precision, hitTest() is an efficient factor.

Once you don’t want that form of precision, and also you don’t wish to bathroom down the processor in pixel-by-pixel testing, you should use hitTest() one other manner, and it’s even easier: simply ship one argument, and make that argument the title of the film clip you’re checking.  So if this script have been connected to the rock:


We’d get a optimistic outcome each time the bounding field of the bullet overlapped with the bounding field of the rock.  Quicker, sloppier.

If the time period “bounding field” appears complicated, merely cease the film and click on on a film clip.  That blue field round it’s the bounding field.  No, it doesn’t exactly match the sprite, until that sprite occurs to be completely box-shaped.  Sure, it is a very tough and inexact manner of detecting collisions.  Typically it’s sufficient.  However not this time.  That’s why the rock is checking extra fastidiously for collisions with the bullet.  And that’s why there are three items of information between the parentheses after hitTest, not only one.

The candy science of collision detection, together with use of the Pythagorean theorem to measure distance – which works very nicely for spherical sprites like, nicely, a rock in an area sport – is elucidated a bit on Colin Moock’s glorious web site.

There are additionally fantastic tutorials on Flashkit and different Flash coding websites.

However I felt it essential to stroll by way of the brand new hitTest() perform, because it’s doubtless for use extensively by Flash sport builders, and the power to do pixel-accurate testing in actual time is particularly nifty.

Director coders who’ve monkeyed with Flash sprites will acknowledge hitTest, which was represented in Lingo years in the past with a Flash Asset Xtra handler known as… nicely, hittest. And it had a form flag too.  However I’m certain that’s only a coincidence…

So we’re on our solution to having a sport.  In the event you like, you may obtain the pattern file and test it out for your self.  We’ve acquired a hero ship, a bullet it may possibly hearth, and a rock that may be shot and destroyed (although for now it merely reappears elsewhere).

Many essential items are nonetheless lacking, although: we want to have the ability to hearth a couple of bullet, we have to have a couple of rock, the rocks want to remain destroyed, and there must be a component of hazard.  However this stuff must await Half III.

Leave a Comment