a

private var attackState:Int = 0;

	private var STATE_ATTACK_IDLE:Int = 0;
	private var STATE_ATTACK_LEFT_SWING:Int = 1;
	private var STATE_ATTACK_LEFT_SWING_FINISHED_WAITING:Int = 2;
	private var STATE_ATTACK_LEFT_SWING_RETURNING:Int = 3;
	private var STATE_ATTACK_LEFT_SWING_TO_RIGHT_SWING:Int = 4;

	private var STATE_ATTACK_RIGHT_SWING:Int = 5;
	private var STATE_ATTACK_RIGHT_SWING_FINISHED_WAITING:Int = 6;
	private var STATE_ATTACK_RIGHT_SWING_RETURNING:Int = 7;
	private var STATE_ATTACK_RIGHT_SWING_TO_LEFT_SWING:Int = 8;

	private var STATE_FROM_BLOCK_TO_ATTACK:Int = 9;
	private var STATE_FROM_IDLE_TO_LEFT:Int = 10;
	private var ENTER_STATE_ATTACK_LEFT_SWING:Int = 11;
	private var ENTER_STATE_ATTACK_RIGHT_SWING:Int = 12;

	private var reduceStaminaFromAttack:Bool = false;
	private var dontUpdateAnimNextFrame:Bool = false;


	private function animationStart( animState:FlxSpAnimation, animName:String,   timer:Float = 0, resetTimerOfCurrentAnimation:Bool = true ):Animation
	{
		var animation:Animation = spine.animation( animState );
		if ( animation != null && resetTimerOfCurrentAnimation ) animation.timer = 0;
		animState.setAnimationByName( animName, false );
		animation = null;
		animation = spine.animation( animState );
		animation.timer = timer;
		return animation;
	}

	private function animationUpdate( animState:FlxSpAnimation, updateSpeed:Float = 1, updateEndPercentage:Float = -1 ):Bool
	{
		var animation:Animation = spine.animation( animState );
		var duration:Float = animation.getDuration();
		if ( updateEndPercentage != -1 ) duration *= updateEndPercentage ;


		animation.timer += updateSpeed  ;
		if ( animation.timer >= duration  )
		{
			animation.timer = duration;
			animation.apply( skeleton, animation.timer, false );

			return true;
		}
		else
		{
			return false;
		}
	}


	public var lastAttackTimePassed:Float = 0;

	private   function attack():Void
	{
		isAttacking = false;

		if ( attackState == STATE_ATTACK_IDLE )
		{
			lastAttackTimePassed += FlxG.elapsed;
		}
		else
		{
			lastAttackTimePassed = 0;
		}

		var animation:Animation = spine.animation( attackAnimState );

		var timeElapsed:Float = this.timeElapsed;
		if ( FlxG.mouse.pressedRight && attackState != STATE_ATTACK_LEFT_SWING && attackState != STATE_ATTACK_RIGHT_SWING )
		{
			timeElapsed *= 4;
		}
		//logs([ spine.getCompletePercentage( attackAnimState ) ]   );
		if ( attackState == STATE_ATTACK_IDLE )
		{
			if ( checkCanAttack( true ) )
			{
				if ( isBlocking == false )
				{

					reduceStamina( ATTACK_STAMINA_COST );
					animation = animationStart( attackAnimState, "AttackNarrow01Start", 0 );
					attackState = STATE_FROM_IDLE_TO_LEFT;
					causedDamage = isAttacking = false;
				}
				else
				{
					attackState = STATE_FROM_BLOCK_TO_ATTACK;
				}

			}
		}
		else if ( attackState == STATE_FROM_IDLE_TO_LEFT )
		{
			if ( animationUpdate( attackAnimState, 1 * timeElapsed ) )
			{
				attackState = ENTER_STATE_ATTACK_LEFT_SWING;
			}
		}
		else if ( attackState == STATE_FROM_BLOCK_TO_ATTACK )
		{
			if ( isBlocking == false )
			{
				reduceStamina( ATTACK_STAMINA_COST );
				attackState = ENTER_STATE_ATTACK_LEFT_SWING;
			}
		}
		else if ( attackState == ENTER_STATE_ATTACK_LEFT_SWING )
		{
			animation = animationStart( attackAnimState, "AttackNarrow01", 0 );
			attackState = STATE_ATTACK_LEFT_SWING;
			causedDamage = isAttacking = false;
		}
		else if ( attackState == STATE_ATTACK_LEFT_SWING )
		{
			if ( nextAttackState == false && reduceStaminaFromAttack )
			{
				reduceStaminaFromAttack = false;
				reduceStamina( ATTACK_STAMINA_COST );
			}

			if ( spine.getTime( attackAnimState ) > 0.2 ) isAttacking = true;

			if ( checkCanAttack() && nextAttackState == false   )
			{
				reduceStaminaFromAttack = true;
				nextAttackState = true;
			}

			if ( animationUpdate( attackAnimState,  1.1 * timeElapsed ) )
			{
				if ( nextAttackState )
				{
					attackState = ENTER_STATE_ATTACK_RIGHT_SWING;
					nextAttackState = false;
				}
				else
				{
					attackState = STATE_ATTACK_LEFT_SWING_FINISHED_WAITING;
				}
			}
		}
		else if ( attackState == ENTER_STATE_ATTACK_RIGHT_SWING )
		{
			causedDamage = isAttacking = false;
			attackState = STATE_ATTACK_RIGHT_SWING;
			animation = animationStart( attackAnimState, "AttackNarrow02", 0 );
		}
		else if ( attackState == STATE_ATTACK_LEFT_SWING_FINISHED_WAITING )
		{
			attackWaitingTimer += timeElapsed;
			if ( checkCanAttack()    )
			{
				reduceStaminaFromAttack = true;
				attackState = ENTER_STATE_ATTACK_RIGHT_SWING;
			}
			else if ( attackWaitingTimer > 0.1 )
			{
				attackWaitingTimer = 0;
				attackState = STATE_ATTACK_LEFT_SWING_RETURNING;
				animation = animationStart( attackAnimState, "AttackNarrow01Return", 0.1 );
			}

		}
		else if ( attackState == STATE_ATTACK_LEFT_SWING_RETURNING )
		{
			if ( checkCanAttack() || spine.getCompletePercentage( attackAnimState ) > 0.4 &&  checkCanAttack( true )    )
			{
				reduceStaminaFromAttack = true;
				attackState = STATE_ATTACK_LEFT_SWING_TO_RIGHT_SWING;
			}

			if( animationUpdate( attackAnimState, 0.5 * timeElapsed ) )
			{
				attackState = STATE_ATTACK_IDLE;
				animation = animationStart( attackAnimState, "HeroIdle01", 0 );
			}
		}
		else if ( attackState == STATE_ATTACK_LEFT_SWING_TO_RIGHT_SWING )
		{
			animation.timer -=  2 * timeElapsed;
			if ( animation.timer <= 0.1 )
			{
				animation.timer = 0.1;
				animation.apply( skeleton, animation.timer, false );
				dontUpdateAnimNextFrame = true;
				attackState = ENTER_STATE_ATTACK_RIGHT_SWING;
			}
		}
		else if ( attackState == STATE_ATTACK_RIGHT_SWING )
		{
			if ( nextAttackState == false && reduceStaminaFromAttack )
			{
				reduceStaminaFromAttack = false;
				reduceStamina( ATTACK_STAMINA_COST );
			}
			if ( spine.getTime( attackAnimState ) > 0.2 ) isAttacking = true;
			if ( checkCanAttack() && nextAttackState == false   )
			{
				reduceStaminaFromAttack = true;
				nextAttackState = true;
			}

			if ( animationUpdate( attackAnimState, 1.1 * timeElapsed, 0.99  ) )
			{

				if ( nextAttackState )
				{
					attackState = ENTER_STATE_ATTACK_LEFT_SWING;
					nextAttackState = false;
				}
				else
				{
					attackWaitingTimer = 0;
					attackState = STATE_ATTACK_RIGHT_SWING_FINISHED_WAITING;
				}
			}

		}
		else if ( attackState == STATE_ATTACK_RIGHT_SWING_FINISHED_WAITING )
		{
			attackWaitingTimer += timeElapsed;
			if ( checkCanAttack()    )
			{
				reduceStaminaFromAttack = true;
				attackState = ENTER_STATE_ATTACK_LEFT_SWING;
			}
			else if ( attackWaitingTimer > 0.1 )
			{
				attackWaitingTimer = 0;
				attackState = STATE_ATTACK_RIGHT_SWING_RETURNING;
				animation = animationStart( attackAnimState,  "AttackNarrow02Return", 0  );
			}

		}
		else if ( attackState == STATE_ATTACK_RIGHT_SWING_RETURNING )
		{
			if ( checkCanAttack()  || spine.getCompletePercentage( attackAnimState ) > 0.33 &&  checkCanAttack( true ) )
			{
				reduceStaminaFromAttack = true;
				attackState = STATE_ATTACK_RIGHT_SWING_TO_LEFT_SWING;
			}

			if ( animationUpdate( attackAnimState, 0.5 * timeElapsed ) )
			{
				attackState = STATE_ATTACK_IDLE;
				animation = animationStart( attackAnimState, "HeroIdle01", 0);
			}

		}
		else if ( attackState == STATE_ATTACK_RIGHT_SWING_TO_LEFT_SWING )
		{
			animation.timer -=  2 * timeElapsed;
			if ( animation.timer <= 0 )
			{
				attackState = ENTER_STATE_ATTACK_LEFT_SWING;
			}
		}



		if ( dontUpdateAnimNextFrame == false )
		{
			animation.apply( skeleton, animation.timer, false );
		}
		dontUpdateAnimNextFrame = false;

		if ( isAttacking )
		{
			checkOverlapWithEnemies();
		}


	}

	private var attackWaitingTimer:Float = 0;
	private var nextAttackState:Bool = false;

	private function checkCanAttack( free:Bool = false ):Bool
	{
		return ( FlxG.mouse.justPressed &&  ( free || stamina >= ATTACK_STAMINA_COST ) );
	}