tutorial.txt

So first thing we want to do is initial setup. Let's get acquainted with our three starter classes:

Main
PlayState
AssetPaths

Main is by default the first thing that runs in a HaxeFlixel game. If there's anything you want to run once and at the very beginning, this is where you'd put it. As is, it just creates a new game.

We want to change this line to 

```
//Make a new flixel game of resolution 256x144 that starts on PlayState
AddChild(new FlxGame(256, 144, PlayState))
```

This line essentially says: 
1. Make a new Flixel Game
2. With resolution 256x144 (which is a widescreen 16:9)
3. And start it on PlayState

PlayState is our first State, which is just what it sounds like - a state of your game. With game dev (and programming in general) you want to focus on compartimentalization - seperating a big task into several smaller tasks. The biggest of these tasks in a game is seperating them into these States. For example, we can have a Menu State, Highscore State, and of course, Play State.

For our tutorial, the majority of our work with placing things on the game to be played with (player, enemies, levels, etc.) will be done in PlayState.

\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

Creating the Player

Let's create a new class that extends FlxSprite called Player

We're going to essentially add some scaffolding for a Player in the form of functions. As I've said before, the focus on this tutorial is not just development but how to organize big tasks into little-er tasks. So let's consider what we want. We want to create a little spaceperson who can shoot, walk, and fly, they'll encounter enemies and get hit by them and if they take enough damage they die. So to break that down we want our player to:

1. Walk
2. Jump/Jetpack
3. Shoot/Charge Missiles
4. Animate their movements
5. Take Damage
6. Die/Respawn

To do all this they'll need some variables. Health, MaxHealth, Missile Fire Rate, etc. And we want all this to be modifiable later through upgrades, so let's really variable it out and intialize those now at the *top* of the class:

```
	/** max speed they on the X axis (horizontal) **/
	var maxSpeed:Int = 100;
	
	/** frames to reach max speed (60 frames per second) **/
	var framesToMaxSpeed:Int = 15;
	
	/** max health (also the default health when the player respawns) **/
	var maxHealth:Int = 100;
	
	/** missile (!!!) charge **/
	var charge:Int = 0;
	
	/** default is full charge after 1/2 second (30/60 frames) **/
	var chargeRate:Int = 30;
	
	/** our intial jump, negative is up **/
	var initialJump:Int = -100;
	
	/** jetpack lift acceleration **/
	var lift:Int = 15;
	
	/** max jetpack lift **/
	var liftMax:Int = 60;
	
	/** max fuel, lose 1 per frame **/
	var fuelMax:Int = 40;
	
	/** frames until fuel is recharged **/
	var fuelRechargeRate:Int = 20;
	
	/** player's current fuel **/
	var fuel:Int = 0;
	
	/** Are we in jetpack mode? **/
	var jetpackMode:Bool = false;
```

This is a lot of variables, and I've added descriptions to each one of them so it looks like even more, and we haven't touched a lick of code that uses any of them so they're kinda just sitting there, but honestly in game design you should expect even more variables then this. It keeps things organized and modifiable as long as you don't go too overboard - always strive to have as many variables as you need and no more, which is of course easier said than done.

So all in all our class should look like this so far:

```

package;

import flixel.FlxSprite;
import flixel.system.FlxAssets.FlxGraphicAsset;


/**
 * A player that walks, jumps, jetpacks, and shoots!
 * @author <Your Name Here>
 */
class Player extends FlxSprite 
{
	/** max speed they on the X axis (horizontal) **/
	var maxSpeed:Int = 100;
	
	/** frames to reach max speed (60 frames per second) **/
	var framesToMaxSpeed:Int = 15;
	
	/** max health (also the default health when the player respawns) **/
	var maxHealth:Int = 100;
	
	/** missile (!!!) charge **/
	var charge:Int = 0;
	
	/** default is full charge after 1/2 second (30/60 frames) **/
	var chargeRate:Int = 30;
	
	/** our intial jump, negative is up **/
	var initialJump:Int = -100;
	
	/** jetpack lift acceleration **/
	var lift:Int = 15;
	
	/** max jetpack lift **/
	var liftMax:Int = 60;
	
	/** max fuel, lose 1 per frame **/
	var fuelMax:Int = 40;
	
	/** frames until fuel is recharged **/
	var fuelRechargeRate:Int = 20;
	
	/** player's current fuel **/
	var fuel:Int = 0;
	
	/** Are we in jetpack mode? **/
	var jetpackMode:Bool = false;
	
	public function new(?X:Float=0, ?Y:Float=0, ?SimpleGraphic:FlxGraphicAsset) 
	{
		super(X, Y, SimpleGraphic);
		
		//just a simple square for now
		makeGraphic(20, 20);
		
		//set the max speed, Flixel won't let the object get any faster than this!
		maxVelocity.x = maxSpeed;
		
		//gravity, down is positive, up is negative
		acceleration.y = 200;
		
		//floor friction
		drag.x = 250;
	}

}

```

This may seem like a long class for something that... well, it doesn't do anything yet. But trust me - this will make your life a lot easier in the future!
 
So what we're going to do here is make a bunch of empty functions that'll act as a in-code "TODO" list. We'll just comment the ones we're not dealing with right now:


```
/** Main player loop **/
override public function update(elapsed:Float):Void 
{
	walk();
	/*
	TODO:
	jump();
	shoot();
	Take Damage functions
	*/
		
	super.update(elapsed);
}
```

Alright, finally time to make our little square move. First, we need to import FlxG, which is a static reference to the game. This allows you to access the primary camera, variables, and most commonly the keys! So let's add `import flixel.FlxG;` at the top of your class, and while we're at it, let's throw in FlxObject which we'll need later. Your imports should look like this:

```
package;

import flixel.FlxG;
import flixel.FlxObject;
import flixel.FlxSprite;
import flixel.system.FlxAssets.FlxGraphicAsset;
```

Now let's, yanno, actually move our square.

Normally you'd want to just set acceleration.x to whatever you want, and you can still do that, but I find it easier to actually have a constant rate of increase measured in frames. It looks a little more complicated in code but overall it's way more controllable. It'll end up looking like this:

```
/** Walk around left to right **/
function walk()
{
	if (FlxG.keys.anyPressed(["LEFT"]))
	{
		//move to the LEFT (negative)
		velocity.x -= maxSpeed / framesToMaxSpeed;
	}
	if (FlxG.keys.anyPressed(["RIGHT"]))
	{
		//move to the RIGHT (positive)
		velocity.x -= maxSpeed / framesToMaxSpeed;
	}
}
```

And that's it! Because we set the drag.x, the player will automatically slow down. Because we set maxVelocity.x, we don't have to worry about them going over the speed limit either!

Optional:

I prefer to do this in my games as it gives smoother movement, which is that you actually accelerate faster when you're trying to turn around quickly. To do that all we need to do is detect if the player is going the opposite direction of the direction they're trying to do, and then just add more velocity.

```
/** Walk around left to right **/
function walk()
{
	if (FlxG.keys.anyPressed(["LEFT"]))
	{
		//move to the LEFT (negative)
		velocity.x -= maxSpeed / framesToMaxSpeed;
		//if we're going to the RIGHT, slow down the player's speed (so they turn around faster)
		if (velocity.x > 0) velocity.x * .95;
	}
	if (FlxG.keys.anyPressed(["RIGHT"]))
	{
		//move to the RIGHT (positive)
		velocity.x += maxSpeed / framesToMaxSpeed;
		//if we're going to the LEFT, slow down the player's speed (so they turn around faster)
		if (velocity.x < 0) velocity.x * .95;
	}
}
```

Okay, let's shift gears for a moment and actually add our player to the game so we can see the result of what we've done. Go back to your PlayState and simply add the Player to the game and store them as a variable. In other words, make your PlayState look like this.

We'll also add a simple test platform and give it collision (by doing a collide check in update, which is called every frame)

```
 
package;

import flixel.FlxSprite;
import flixel.FlxState;
import flixel.FlxG;

class PlayState extends FlxState
{
	var player:Player;
	var testPlatform:FlxSprite;
	
	override public function create():Void
	{
		super.create();
		
		//add and assign the player variable in one line, nifty!
		add(player = new Player(100, 100));
		
		//make a simple test platform
		add(testPlatform = new FlxSprite(0, player.y + player.height));
		//creates a simple rectangle
		testPlatform.makeGraphic(FlxG.width, 100);
		//stops the platform from moving when the player touches it
		testPlatform.immovable = true;
	}

	override public function update(elapsed:Float):Void
	{
		//give the testPlatform Collision with the player
		FlxG.collide(player, testPlatform);
		
		super.update(elapsed);
	}
}


```

Okay so if we run the game you'll see your little square no longer falls to the abyss, yay! Now we need to make them jump. Jump code is really easy in Flixel, all we need to understand is

1. How to detect when we're on the floor
2. How to make the character jump !

So let's update our TODO in the Update() function to

override public function update(elapsed:Float):Void 
{
	walk();
	jump();
	/*
	TODO:
	shoot();
	Take Damage functions
	*/
		
	super.update(elapsed);
}

```

And make our jump function:
	
```

/** Press UP to jump! **/
function jump() {
	//1. Detect we're on the floor
	var onGround:Bool = isTouching(FlxObject.FLOOR);
	
	//2. If we're on the ground...
	if (onGround) 
	{
		//We can jump if the UP key is pressed!
		if (FlxG.keys.anyJustPressed(["UP"])){
			velocity.y = initialJump;
		}
	}
}

```

If you run it now and press up, you should be able to jump!

Admittedly, it's not that high of a jump, and that's because of this next bit, the jetpack! Basically, if we're on the floor and pressing UP we'll switch to jetpack mode, as long as we have fuel, we'll have lift. So to break it down:
	
1. If we press UP and we have fuel
2. Add lift and decrease fuel
3. When they're on the floor, add fuel back.

When the player holds up, the jetpack will carry their lift. We're also adding a max lift so that they don't go off the rails and just go infinitely higher. In addition, when they're on the floor. So add this to the end of jump()

```

//Jetpack handler
//J1. If we hold UP and we have fuel
if (FlxG.keys.anyPressed(["UP"]) && fuel > 0) 
{
	//J2. Add lift and decrease fuel
	velocity.y -= lift;
	fuel--;
	//Max velocity so they don't go flying infinitely faster
	if (velocity.y < -liftMax) {
		velocity.y = -liftMax;
	}
}
//J3. When they're on the floor, add fuel back.
if (onGround) 
{
	//They'll recharge in 20 frames
	fuel += Math.ceil(fuelMax / 20);
	if (fuel > fuelMax) {
		fuel = fuelMax;
	}
}

```

Hold up now. If you test your game you'll see the controls for jump and jetpack overlap, and the result is if you're holding down jump you'll immediately start wasting jetpack fuel. So to game design around this, let's change the controls a bit - when you let go of jump and press it again midair, you'll start using your jetpack! So let's use that variable called "jetpackMode" we initialized all the way back in the beginning which is only True if the player released the jump button. It is set back to False if they touch the ground. So overall our jump code should look like this:

```

/** Press UP to jump! **/
function jump() {
	//1. Detect we're on the floor
	var onGround:Bool = isTouching(FlxObject.FLOOR);
	
	//2. If we're on the ground...
	if (onGround) 
	{
		//We can jump if the UP key is pressed!
		if (FlxG.keys.anyJustPressed(["UP"])){
			velocity.y = initialJump;
		}
	}
	
	//Jetpack handler
	//J1. If we hold UP and we have fuel
	if (FlxG.keys.anyPressed(["UP"]) && fuel > 0 && jetpackMode) 
	{
		//J2. Add lift and decrease fuel
		velocity.y -= lift;
		fuel--;
		//Max velocity so they don't go flying infinitely faster
		if (velocity.y < -liftMax) {
			velocity.y = -liftMax;
		}
	}
	//J3. When they're on the floor, add fuel back.
	if (onGround) 
	{
		//If we're on the floor, we reset jetpackMode
		jetpackMode = false;
		//They'll recharge in fuelRechargeRate frames
		fuel += Math.ceil(fuelMax / fuelRechargeRate);
		if (fuel > fuelMax) {
			fuel = fuelMax;
		}
	}
	
	//J4. Use jetpack only when the key is released and pressed again afterwards
	if (!onGround && FlxG.keys.anyJustReleased(["UP"]))
	{
		jetpackMode = true;
	}
}
	
```

Okay time to animate our little guy. Why now? Because if we wanna give him a gun, well, we're gonna need to know where to put it - trust me it's a LOT easier to do that after you get the base sprite going at least. Anyhow, if you look in your images folder you'll notice our sprite sheet called astro.png. Get it? They're an astronaut... named astro... okay anyways AssetPaths does a nifty magic thing (how it does it is way outside the scope of this tutorial) where it automatically makes static references to any assets you put in to your assets folder. So in our case, `AssetPaths.astro__png` is how we'd access our image. Things to note about HaxeFlixel is it only accepts spritesheets that are 1. the same size for every frame 2. read left to right. Anything else and you're asking for trouble. So make sure to use Aseprite or another neat program when making your sprite and just export it normally using that, it handles those details for you and HaxeFlixel will be happy with you (and so will I.)

Anyways yea so this sprite is 4 frames each 8x9 pixels. That's all we need to know about it, really. Now let's delete that old "MakeGraphic" line and instead load the image and animations like so:
	
```

//adding animations
loadGraphic(AssetPaths.astro__png, true, 8, 9, true);
animation.add("idle", [0]);
animation.add("walk", [1, 2], 6, true);
animation.add("jump", [3]);

//our guy is facing right by default, so if he turns left we should flip it
setFacingFlip(FlxObject.RIGHT, false, false);
setFacingFlip(FlxObject.LEFT, true, false);

```

Now we can add a new function at the end of our update right before `super.update(elapsed)` called `animationHandler()`. This decides on what animation to play, which we'll call using `animation.play();` So let's do this:
	
```

/** picks an animation to play **/
function animationHandler()
{
	var isWalking:Bool = velocity.x != 0;
	var isJumping:Bool = !isTouching(FlxObject.FLOOR);
	
	//walking animation only when you're walking on the ground
	if (isWalking && !isJumping)
		animation.play("walk");
	
	//jumping animation is always when you're in the air
	if (isJumping)
		animation.play("jump");
	
	//idle animation only when you're on the floor
	if (!isWalking && !isJumping)
		animation.play("idle");
		
	//turn around when you're going in the opposite direction, but only if you're actually moving
	if (velocity.x != 0){
		if (velocity.x < 0){
			facing = FlxObject.LEFT;
		}else{
			facing = FlxObject.RIGHT;
		}
	}
}
	
```

I used some funky shorthands to make this more readable - in coding you can assign a variable to a statement just like you can to an integer. It makes things more readable in some cases if your statement isn't too long. Same thing with non-curly brace ifs which only work if you have a single line that follows.

Anyhow, run it and you can see your little square is now an even little-er astronaut!

Okay, now to address a little something that's been bothering me and probably bothering you - who the heck uses UP for a default jump button? Let's fix that. But first, I'm gonna make this a lot more manageable for everyone involved. Let's add these variables to the top of our class:
	
	```
	//Controls
	rightButton = false;
	leftButton = false;
	jumpButtonPressed = false;
	jumpButtonHeld = false;
	jumpButtonReleased = false;
	shootButtonPressed = false;
	shootButtonHeld = false;
	shootButtonReleased = false;
	```
	
	Now let's add a new function called updateControls at the beginning of our Player's update loop.
	
	```
	rightButton = FlxG.keys.anyPressed(["RIGHT"]);
	leftButton = FlxG.keys.anyPressed(["LEFT"]);
	jumpButtonPressed = FlxG.keys.anyJustPressed(["UP", "Z"]);
	jumpButtonHeld = FlxG.keys.anyPressed(["UP", "Z"]);
	jumpButtonReleased = FlxG.keys.anyJustReleased(["UP", "Z"]);
	shootButtonPressed = FlxG.keys.anyJustPressed(["X", "SPACE"]);
	shootButtonHeld = FlxG.keys.anyPressed(["X", "SPACE"]);
	shootButtonReleased = FlxG.keys.anyJustReleased(["X", "SPACE"]);
	```
	
	Just for kicks let's also add in GamePad controls. These will work with practically any GamePad you plug in - Xbox, Pro Controller, PS4, some knock off. Put this after that last bit of code, don't forget to import `flixel.input.gamepad.FlxGamepad` and `flixel.input.gamepad.FlxGamepadInputID` first, though!
	
	```
	//joystick deadzone so minor movements don't get detected, feel free to tweak this
	var deadzone:Float = 0.1;
	
	gamepad = FlxG.gamepads.getFirstActiveGamepad();
	
	if(gamepad) 
	{
		rightButton = rightButton || gamepad.analog.value.LEFT_STICK_X > deadzone || gamepad.anyPressed([FlxGamepadInputID.DPAD_RIGHT]);
		leftButton = leftButton || gamepad.analog.value.LEFT_STICK_X < deadzone || gamepad.anyPressed([FlxGamepadInputID.DPAD_LEFT]);
		jumpButtonPressed = jumpButtonPressed || gamepad.anyJustPressed([FlxGamepadInputID.A]);
		jumpButtonHeld = jumpButtonHeld || gamepad.anyPressed([FlxGamepadInputID.A]);
		jumpButtonReleased = jumpButtonReleased || gamepad.anyJustReleased([FlxGamepadInputID.A]);
		shootButtonPressed = shootButtonPressed || gamepad.anyJustPressed([FlxGamepadInputID.X]);
		shootButtonHeld = shootButtonHeld || gamepad.anyPressed([FlxGamepadInputID.X]);
		shootButtonReleased = shootButtonReleased || gamepad.anyJustReleased([FlxGamepadInputID.X]);
	}
	```
	
	Okay yea so that should do it. Now just replace all instances of ye olde jump and arrow key code with those variables and now your whole game should work with pretty much any keyboard or controller :)
	
	So, as a checkpoint, your entire player code should now look like this:
		
	'''
	
	package;

	import flixel.FlxG;
	import flixel.FlxSprite;
	import flixel.FlxObject;
	import flixel.system.FlxAssets.FlxGraphicAsset;
	import flixel.input.gamepad.FlxGamepad;
	import flixel.input.gamepad.FlxGamepadInputID;


	/**
	 * A player that walks, jumps, jetpacks, and shoots!
	 * @author <Your Name Here>
	 */
	class Player extends FlxSprite 
	{
		/** max speed they on the X axis (horizontal) **/
		var maxSpeed:Int = 100;
		
		/** frames to reach max speed (60 frames per second) **/
		var framesToMaxSpeed:Int = 15;
		
		/** max health (also the default health when the player respawns) **/
		var maxHealth:Int = 100;
		
		/** default is full charge after 1/2 second (30/60 frames) **/
		var chargeRate:Int = 30;
		
		/** our intial jump, negative is up **/
		var initialJump:Int = -100;
		
		/** jetpack lift acceleration **/
		var lift:Int = 15;
		
		/** max jetpack lift **/
		var liftMax:Int = 60;
		
		/** max fuel, lose 1 per frame **/
		var fuelMax:Int = 40;
		
		/** frames until fuel is recharged **/
		var fuelRechargeRate:Int = 20;
		
		/** player's current fuel **/
		var fuel:Int = 0;
		
		/** Are we in jetpack mode? **/
		var jetpackMode:Bool = false;
		
		//Controls
		var rightButton:Bool = false;
		var leftButton:Bool = false;
		var jumpButtonPressed:Bool = false;
		var jumpButtonHeld:Bool = false;
		var jumpButtonReleased:Bool = false;
		var shootButtonPressed:Bool = false;
		var shootButtonHeld:Bool = false;
		var shootButtonReleased:Bool = false;
		
		public function new(?X:Float=0, ?Y:Float=0, ?SimpleGraphic:FlxGraphicAsset) 
		{
			super(X, Y, SimpleGraphic);
			
			//adding animations
			loadGraphic(AssetPaths.astro__png, true, 8, 9, true);
			animation.add("idle", [0]);
			animation.add("walk", [1, 2], 6, true);
			animation.add("jump", [3]);
			
			//our guy is facing right by default, so if he turns left we should flip it
			setFacingFlip(FlxObject.RIGHT, false, false);
			setFacingFlip(FlxObject.LEFT, true, false);
			
			//set the max speed, Flixel won't let the object get any faster than this!
			maxVelocity.x = maxSpeed;
			
			//gravity, down is positive, up is negative
			acceleration.y = 200;
			
			//floor friction
			drag.x = 250;
		}
		
		/** main player loop **/
		override public function update(elapsed:Float):Void 
		{
			updateControl();
			walk();
			jump();
			/*
			TODO:
			shoot();
			Take Damage functions
			*/
			
			animationHandler();
			
			super.update(elapsed);
		}
		
		/** Updates controls **/
		function updateControl(){
			//1. Keyboard Controls
			rightButton = FlxG.keys.anyPressed(["RIGHT"]);
			leftButton = FlxG.keys.anyPressed(["LEFT"]);
			jumpButtonPressed = FlxG.keys.anyJustPressed(["UP", "Z"]);
			jumpButtonHeld = FlxG.keys.anyPressed(["UP", "Z"]);
			jumpButtonReleased = FlxG.keys.anyJustReleased(["UP", "Z"]);
			shootButtonPressed = FlxG.keys.anyJustPressed(["X", "SPACE"]);
			shootButtonHeld = FlxG.keys.anyPressed(["X", "SPACE"]);
			shootButtonReleased = FlxG.keys.anyJustReleased(["X", "SPACE"]);
			
			//2. Joystick Controls
			
			//joystick deadzone so minor movements don't get detected, feel free to tweak this
			var deadzone:Float = 0.1;
			
			var gamepad:FlxGamepad = FlxG.gamepads.getFirstActiveGamepad();
			
			if(gamepad != null) 
			{
				rightButton = rightButton || gamepad.analog.value.LEFT_STICK_X > deadzone || gamepad.anyPressed([FlxGamepadInputID.DPAD_RIGHT]);
				leftButton = leftButton || gamepad.analog.value.LEFT_STICK_X < deadzone || gamepad.anyPressed([FlxGamepadInputID.DPAD_LEFT]);
				jumpButtonPressed = jumpButtonPressed || gamepad.anyJustPressed([FlxGamepadInputID.A]);
				jumpButtonHeld = jumpButtonHeld || gamepad.anyPressed([FlxGamepadInputID.A]);
				jumpButtonReleased = jumpButtonReleased || gamepad.anyJustReleased([FlxGamepadInputID.A]);
				shootButtonPressed = shootButtonPressed || gamepad.anyJustPressed([FlxGamepadInputID.X]);
				shootButtonHeld = shootButtonHeld || gamepad.anyPressed([FlxGamepadInputID.X]);
				shootButtonReleased = shootButtonReleased || gamepad.anyJustReleased([FlxGamepadInputID.X]);
			}
		}
		
		/** Move left and right **/
		function walk() {
			if (leftButton) 
			{
				//move to the LEFT (negative)
				velocity.x -= maxSpeed / framesToMaxSpeed;
				//if we're going to the RIGHT, slow down the player's speed (so they turn around faster)
				if (velocity.x > 0) velocity.x * .95;
			}
			if (rightButton) 
			{
				//move to the RIGHT (positive)
				velocity.x += maxSpeed / framesToMaxSpeed;
				//if we're going to the LEFT, slow down the player's speed (so they turn around faster)
				if (velocity.x < 0) velocity.x * .95;
			}
		}
		
		/** Press UP to jump! **/
		function jump() {
			//1. Detect we're on the floor
			var onGround:Bool = isTouching(FlxObject.FLOOR);
			
			//2. If we're on the ground...
			if (onGround) 
			{
				//We can jump if the UP key is pressed!
				if (jumpButtonPressed){
					velocity.y = initialJump;
				}
			}
			
			//Jetpack handler
			//J1. If we hold UP and we have fuel
			if (jumpButtonHeld && fuel > 0 && jetpackMode) 
			{
				//J2. Add lift and decrease fuel
				velocity.y -= lift;
				fuel--;
				//Max velocity so they don't go flying infinitely faster
				if (velocity.y < -liftMax) {
					velocity.y = -liftMax;
				}
			}
			//J3. When they're on the floor, add fuel back.
			if (onGround) 
			{
				//If we're on the floor, we reset jetpackMode
				jetpackMode = false;
				//They'll recharge in fuelRechargeRate frames
				fuel += Math.ceil(fuelMax / fuelRechargeRate);
				if (fuel > fuelMax) {
					fuel = fuelMax;
				}
			}
			
			//J4. Use jetpack only when the key is released and pressed again afterwards
			if (!onGround && jumpButtonReleased)
			{
				jetpackMode = true;
			}
		}
		
		/** picks an animation to play **/
		function animationHandler()
		{
			var isWalking:Bool = velocity.x != 0;
			var isJumping:Bool = !isTouching(FlxObject.FLOOR);
			
			//walking animation only when you're walking on the ground
			if (isWalking && !isJumping)
				animation.play("walk");
			
			//jumping animation is always when you're in the air
			if (isJumping)
				animation.play("jump");
			
			//idle animation only when you're on the floor
			if (!isWalking && !isJumping)
				animation.play("idle");
				
			//turn around when you're going in the opposite direction, but only if you're actually moving
			if (velocity.x != 0){
				if (velocity.x < 0){
					facing = FlxObject.LEFT;
				}else{
					facing = FlxObject.RIGHT;
				}
			}
		}
	}
```

///////////////////////////////


Alright, what's next? Violence. Guns. Mwahahaha! Yes our astronaut with their arm raised out actually has a little arm blaster. Use your imagination.

First let's create a simple bullet class in a new file called `Bullet.hx`


```
package;

import flixel.FlxSprite;

/**
 * A simple square that contains data on damage
 * @author <Your Name Here>
 */
class Bullet extends FlxSprite
{
	/** how much damage our bullet does **/
	public var dmg:Int = 1;
	
	/** how long our bullet stays active (in frames) **/
	var lifeSpan:Int = 180;
	
	public function new(X:Float = 0, Y:Float = 0, velX:Float = 0, velY:Float = 0, strength:Int = 1)
	{
		super(X, Y);
		//set our damage
		dmg = strength;
		
		//make a simple square
		makeGraphic(2, 2);
		
		//set velocity the easy way
		velocity.set(velX, velY);
		
		//add it to our bullet layer
		PlayState.bullets.add(this);
	}

	override public function update(elapsed:Float):Void
	{
		lifeSpan--;
		if (lifeSpan <= 0) kill();
		super.update(elapsed);
	}
	
	override function kill(){
		//clean up bullets a bit by removing this bullet from it
		PlayState.bullets.remove(this, true);
		super.kill();
	}

}

```

In order to add bullets, we'll need to understand FlxTypedGroups. These are fancy little groups that you can pass in many functions as opposed to a simple FlxSprite or FlxObject to perform that on multiple objects at once. It also can be treated like a "layer" in your game.

Add a new FlxTypedGroup<Bullet> constructor in `PlayState` so your declarations look like this:

```
var player:Player;
var testPlatform:FlxSprite;
public static var bullets:FlxTypedGroup<Bullet>;
```

Then initialize at the end of `create` so it looks like this:
	
```
//make a group of bullets
add(bullets = new FlxTypedGroup<Bullet>());
```

Awesome. Now let's add `shoot()` code. Uncomment `shoot()` in Player's `update()` function and add this block, which will make a bullet that is dependent on the player's facing direction. Remember the player is by default facing Right!

```

/** Shoots a bullet **/
function shoot()
{
	if (shootButtonPressed){
		var bulletSpeedX:Int = 150;
		//the edge of the sprite
		var bulletX:Float = x + width;
		//about where the arm is
		var bulletY:Float = y + 5;
		//if facing left
		if (flipX) {
			//reverse the speed
			bulletSpeedX = -bulletSpeedX;
			//opposite edge of the sprite - bullet width
			bulletX = x - 2;
		}
		PlayState.bullets.add(new Bullet(bulletX, bulletY, bulletSpeedX, 0, 1));
	}
}

```

Groovy. Now let's add missiles for a bit extra oomph. When our player charges their gun and releases, they fire of a spicy missile. First let's create the Missile class that inherits from Bullet

```
package;

import flixel.FlxSprite;
import flixel.FlxObject;

/**
 * A spicy missile
 * @author <Your Name Here>
 */
class Missile extends Bullet 
{
	var maxMissileVelocity:Int = 200;
	
	public function new(X:Float=0, Y:Float=0, velX:Float=0, velY:Float=0, team:Int=0) 
	{
		super(X, Y - 1, velX, velY, team);
		
		loadGraphic(AssetPaths.missile__png);
		
		setFacingFlip(FlxObject.RIGHT, false, false);
		setFacingFlip(FlxObject.LEFT, true, false);
		
		maxVelocity.x = maxMissileVelocity;
		
		if (velocity.x > 0){
			facing = FlxObject.LEFT;
			x -= 3; //difference in size between a missile and a bullet is 3
		}
		
		//missile starts slow
		velocity.x = velocity.x / 10;
	}
	
	override public function update(elapsed:Float):Void 
	{
		//then gets rapidly faster
		velocity.x = velocity.x * 1.2;
		super.update(elapsed);
	}
	
}
```

This missile starts slower than a bullet but really picks up speed! Now we can add it to the `shoot()` function.

```
/** Shoots a bullet or missile **/
function shoot()
{
	if (shootButtonHeld) charge++;
	
	//switch to misisles if charge is complete
	var missileMode:Bool = charge >= chargeRate;
	
	//our two conditions handle inputs for regular bullets or missiles
	if (shootButtonPressed || shootButtonReleased && missileMode) {
		var bulletSpeedX:Int = 150;
		//the edge of the sprite
		var bulletX:Float = x + width;
		//about where the arm is
		var bulletY:Float = y + 5;
		//if facing left
		if (facing == FlxObject.LEFT) {
			//reverse the speed
			bulletSpeedX = -bulletSpeedX;
			//opposite edge of the sprite - bullet width
			bulletX = x - 2;
		}
		//shoot a regular bullet
		if (!missileMode){
			PlayState.bullets.add(new Bullet(bulletX, bulletY, bulletSpeedX, 0, 1));
		}
		//shoot a missile
		if (missileMode){
			PlayState.bullets.add(new Missile(bulletX, bulletY, bulletSpeedX, 0, 5));
		}
	}
	
	if (shootButtonReleased){
		charge = 0;
	}
}
```

Yes this means you can't actually avoid shooting a bullet before you shoot a missile. There's a couple control ways around that but it's not enough of a problem to warrant time in this tutorial. Instead let's look at giving our little Astronaut something to actually shoot at. We'll have a tiny crawler enemy, they're not very bright, they just walk left to right and if they hit a wall they turn around. Oh well. Anyways, let's make Crawler.