Ready to watch this entire course?
Become a member and get unlimited access to the entire skills library of over 4,900 courses, including more Developer and personalized recommendations.Start Your Free Trial Now
- View Offline
Starting with installation and configuration of Starling and creation of a Flash Builder project, the course shows how to prepare and import graphical assets, create MovieClip classes from sprite sheets, manage various gaming objects, detect collisions, and add both particle and sound effects. The finished game can be deployed to any browser or mobile device that integrates Flash Player 11, which was released in September 2011.
- Downloading and installing Starling and Flash Builder
- Creating the project
- Creating the main game class, static assets class, and other classes
- Building the state machine
- Creating a static assets class
- Adding images
- Creating sprite sheets with Texture Packer
- Creating and importing bitmap fonts
- Detecting collisions
- Adding particle effects
- Adding sound effects
Skill Level Intermediate
So now that we've created our explosion particle class here, we're going to create an ExplosionManager to help track these in our game. So I'm going to right-click on the managers package, New > ActionScript Class, and this is going to be ExplosionManager, and click Finish. Now much like the other managers, we're going to send in our play state to the constructor, and I'm going to set that as an instance variable, this.play = play.
Okay, so much like the AlienManager and the BulletManager, we're going to use an object pool here to hold our particle effects. These are the things that you don't want to be instantiating in the middle of your gameplay. So I'm going to create a variable called pool, and that's going to be equal to new StarlingPool. and for the type it's going to be a type of Explosion, make sure we import that. And we're going to create 15 of them, and again that's a number that you're going to have to trial and error depending on your game for the least number that you can get away with.
And what we're going to do is to create a public function called Spawn, which is going to spawn a new explosion. So public function spawn, and we're going to pass in an X and a Y value for where in the game we want it to spawn, and this is something we're going to be calling from the CollisionManager class. So I'm going to say our X property of type int, Y property of type int, we're not going to be returning anything, and now let's get a new explosion from the pool, so I'll create a local reference variable, I'll just call it ex, and we'll say pool.getSprite() as Explosion.
And now we want to set the emitterX and the emitterY property of our explosion, and we're going to set it to that X property that was sent in to this function. We'll set emitterY = y, and now we want to start our particle effect, so we're going to call that start method. But for this we do want to pass in a duration, because we don't want this to be like a sparkler that just keeps going. So we're going to put 0.1 seconds in here for the duration of the particle effect.
Now we want to add this particle effect to our play state, so we're going to say play.addChild(ex), and much like we did for the smoke particle, we need to add it to the juggler, so Starling.juggler. add(ex), and what we need now is to know when this particle effect is finished, essentially it's going to blow up and it's going to make all these stars come out.
We want to know when it's actually finished, so that we can clean up after ourselves and return it to the pool. Well there is a complete event on the PD particle designer class, so we'll listen for that. So ex.addEventListener and we want Starling.events and we want the COMPLETE event. And we'll just have it call a function called onComplete, and go ahead and create that method, and make sure we are catching our event object as well.
Okay, so in the onComplete we essentially want to clean up that particle effect and return it to the pool. So first I'm going to get a local reference to it and so var ex of type Explosion = event.currentTarget as Explosion, and that gives us a reference to the particle effect that is finished here. And what we want to do most importantly is to remove this from the juggler, so Starling.juggler.remove(ex).
And now we want to return it to the pool, and just to be on the safe side here, we're going to do a check to make sure if pool is not equal to null then we're going to say pool.returnSprite(ex). And the reason is once we get down to our destroy method for this, it's possible that this might actually fire after we've killed the pool, so just to be safe we're going to put that line in there. So now we need a public function which is going to be our destroy method.
So we're going to say public function destroy. Now these particle effects are one of the more trickier things to remove from memory, so I'm going to show you how we're going to go about doing that. We're going to go do a for loop, so we can loop through all the items in our pool. So we're going to say for(var i:int=0; i<pool.items, which is the items array in our actual Starling Pool class, .length; i++).
And let's get a reference to that item, so let's say var ex:Explosion = pool.items i, and we're going to say ex.dispose(). So that's an important thing that we need to do is to call the dispose method of that particle, and then we're going to set ex = null. So after we do that, then we're going to actually destroy the pool, so pool.destroy(); and then we'll set pool also equal to null.
And that will successfully remove our particle effects from memory. So now we have our ExplosionManager, now we actually need to create that ExplosionManager in our play state, where we created the other ones. So I'm going to come under CollisionManager and create it here is equal to new ExplosionManager. Now we could create this in the CollisionManager class, but I prefer to create it here in our play state, create that as an instance variable, and we're going to need to create this public, because we're going to need to reference it from our CollisionManager.
So now what I want to do is to go into my CollisionManager class and I want to make one of these explosions happen. So here while we're testing between bullets and aliens, if we determine that a collision has happened, what we want to do is to go play.ExplosionManager.spawn and give it the position where we want this to spawn, while we want to actually do it from a.x and a.y.
And actually, let's move this before we actually call those destroy methods, like that. Okay let's go ahead and test it now. We'll run, and now you can see we have those cool particle effects happening whenever a bullet touches one of the aliens, and you can imagine easily creating multiple of these types of particle effects for different things that happen in your game. Now it's important to note that you can also adjust properties like the color of these particles at run time.
So let's say we also had red aliens, and we wouldn't have to create a whole new particle effect, we can just change the particular color of these existing particle effects. So really cool that we can easily add these kind of eye candy effects to our game using the particle extension in Starling.