public void OnExecuteAction ( object[] args )
	{
		if ( MyAction.Name == "Punch" )
		{
			SoundManager.Instance.PlayExecutePunchSound ();
		}
		else if ( MyAction.Name == "Slash" )
		{
			SoundManager.Instance.PlaySlashSound ();
		}
		else if ( MyAction.Name == "Super Slash" )
		{
			SoundManager.Instance.PlaySlash2Sound ();
		}
		else if ( MyAction.Name == "Hyper Slash" )
		{
			SoundManager.Instance.PlaySlash3Sound ();
		}

		ownerPlayer = args[0] as Player;
		MyAction = args[1] as PlayerAction;
		targetPlayer = args[2] as Player;

		this.transform.parent = ownerPlayer.SlashHotzone.transform;
		this.transform.localPosition = new Vector3 ();
		this.transform.localRotation = Quaternion.identity;
		this.transform.localScale = new Vector3 ( 1, 1, 1 );

		OnDoDamaged ( targetPlayer );
	}

        public override Node AdvanceHead(PlayerAction action)
        {
            Assert.That(action == PlayerAction.Raise || action == PlayerAction.Call);

            if (action == PlayerAction.Raise) return RaiseBranch;
            else return CheckBranch;
        }

	public GamepadInControlActionSet()
	{
		// Joystick
		Left = CreatePlayerAction("MoveLeft");
		Right = CreatePlayerAction("MoveRight");
		Up = CreatePlayerAction("MoveUp");
		Down = CreatePlayerAction("MoveDown");

		Movement = CreateTwoAxisPlayerAction(Left, Right, Down, Up);

		// Actions
		Jump = CreatePlayerAction("Jump");

		Break = CreatePlayerAction("Break");

		Dash = CreatePlayerAction("Dash");

		Accelerate = CreatePlayerAction("Accelerate");

		Desaccelerate = CreatePlayerAction("desaccelerate");


		// Menu
		Command = CreatePlayerAction("Command");
	}

 /// <summary>
 /// Gets the binding that is specific to the player action.
 /// </summary>
 /// <returns>The binding that is caused by the action.</returns>
 public static Binding GetBinding(PlayerAction action)
 {
     // using tryGetValue here to stop an incorrect index (throws an exception)
     Binding binding;
     binds.TryGetValue(action, out binding);
     return binding;
 }

    public PlayerActions()
        : base()
    {
        L_Left = CreatePlayerAction("Left stick left");
        L_Right = CreatePlayerAction("Left stick right");
        L_Up = CreatePlayerAction("Left stick up");
        L_Down = CreatePlayerAction("Left stick down");

        R_Left = CreatePlayerAction("Right stick left");
        R_Right = CreatePlayerAction("Right stick right");
        R_Up = CreatePlayerAction("Right stick up");
        R_Down = CreatePlayerAction("Right stick down");

        Move = CreateTwoAxisPlayerAction(
            L_Left,
            L_Right,
            L_Down,
            L_Up);

        Look = CreateTwoAxisPlayerAction(
            R_Left,
            R_Right,
            R_Down,
            R_Up);

        Fire = CreatePlayerAction("Fire");
        Join = CreatePlayerAction("Join");
    }

 public PokerAction(PlayerMobile actor, PlayerAction action, PokerGameState state, int amountbet)
 {
     PlayerSerial = actor.Serial;
     Type = (int) action;
     State = (int) state;
     Amount = amountbet;
 }

 /// <summary>
 /// Adds the specified keybind to the specified action.
 /// </summary>
 public static void AddKeybind(PlayerAction action, Binding bind)
 {
     if (binds.ContainsKey(action))
         binds[action] = bind;
     else
         binds.Add(action, bind);
 }

    public PlayerActions()
    {
        this.Skills = new PlayerAction[4];

        this.Shoot = this.CreatePlayerAction( "Shoot" );
        for (int i = 0; i < 4; i++)
        {
            this.Skills[i] = this.CreatePlayerAction( "Skill" + i );
        }

        this.YesOrOk = this.CreatePlayerAction( "Yes" );
        this.NoOrBack = this.CreatePlayerAction ( "No" );

        this.ILeft = this.CreatePlayerAction( "ILeft");
        this.IRight = this.CreatePlayerAction( "IRight");
        this.IUp = this.CreatePlayerAction( "IUp");
        this.IDown = this.CreatePlayerAction( "IDown");

        this.moveUp = this.CreatePlayerAction( "MoveUp" );
        this.moveDown = this.CreatePlayerAction( "MoveDown" );
        this.moveLeft = this.CreatePlayerAction( "MoveLeft" );
        this.moveRight = this.CreatePlayerAction( "MoveRight" );

        this.aimUp = this.CreatePlayerAction( "AimUp" );
        this.aimDown = this.CreatePlayerAction( "AimDown" );
        this.aimRight = this.CreatePlayerAction ( "AimRight" );
        this.aimLeft = this.CreatePlayerAction ( "AimLeft" );

        this.Movement = this.CreateTwoAxisPlayerAction(this.moveLeft, this.moveRight, this.moveDown, this.moveUp);
        this.Aim = this.CreateTwoAxisPlayerAction(this.aimLeft, this.aimRight, this.aimDown, this.aimUp);
    }

 protected InternalThreat(ThreatType type, ThreatDifficulty difficulty, int health, int speed, int timeAppears, StationLocation currentStation, PlayerAction actionType, ISittingDuck sittingDuck)
     : base(type, difficulty, health, speed, timeAppears, sittingDuck)
 {
     CurrentStation = currentStation;
     sittingDuck.StationByLocation[currentStation].Threats.Add(this);
     ActionType = actionType;
 }

    /** Checks whether the player was on beat or not **/
    protected void HandlePlayerTimings(PlayerAction playerAction)
    {
        // Only handles timings once per FixedUpdate
        if (timingsHandled)
        {
            return;
        }
        timingsHandled = true;

        TimingsManager.TimingResult result;
        List<int> triggers;
        bool debugWorthShowing = true;
        if (playerAction != PlayerAction.NONE)
        {
            result = timingsManager.checkAttempt(musicAudioSource.time, out triggers);
        }
        else
        {
            // User didn't make an attempt and had missed the timing window
            result = timingsManager.checkForMiss(musicAudioSource.time, out triggers);

            if (result == TimingsManager.TimingResult.NO_BEAT)
            {
                debugWorthShowing = false;
            }
        }

        if (showDebugTimingResults && debugWorthShowing)
        {
            Debug.Log("BaseChoreographer " + Time.time + ": " + result.ToString());
        }

        PlayerTimingResult(result, triggers, playerAction);
    }

	public MonkActions(InputDevice device)
	{
		spawn0 = CreatePlayerAction ("Spawn0");
		spawn1 = CreatePlayerAction ("Spawn1");
		spawn2 = CreatePlayerAction ("Spawn2");
		spawn3 = CreatePlayerAction ("Spawn3");
		fireTurret = CreatePlayerAction ("FireTurret");
		moveUnitLeft = CreatePlayerAction ("MoveUnitLeft");
		moveUnitRight = CreatePlayerAction ("MoveUnitRight");
		moveHorizontal = CreateOneAxisPlayerAction (moveUnitLeft, moveUnitRight);

		moveUnitUp = CreatePlayerAction ("MoveUnitUp");
		moveUnitDown = CreatePlayerAction ("MoveUnitDown");
		moveVertical = CreateOneAxisPlayerAction (moveUnitDown,moveUnitUp);

		Device = device;

		spawn0.AddDefaultBinding (InputControlType.Action1);
		spawn1.AddDefaultBinding (InputControlType.Action2);
		spawn2.AddDefaultBinding (InputControlType.Action3);
		spawn3.AddDefaultBinding (InputControlType.Action4);
		fireTurret.AddDefaultBinding (InputControlType.RightTrigger);

		moveUnitLeft.AddDefaultBinding (InputControlType.LeftStickLeft);
		moveUnitRight.AddDefaultBinding (InputControlType.LeftStickRight);
		moveUnitUp.AddDefaultBinding (InputControlType.LeftStickUp);
		moveUnitDown.AddDefaultBinding (InputControlType.LeftStickDown);

	}

	public bool PlayAction ( Player owner, PlayerAction action, Vector2 point0, Vector2 point1 )
	{
        if (action.Name == "Punch")
        {
            SoundManager.Instance.PlayExecutePunchSound();
        }
        else if (action.Name == "Slash")
        {
            SoundManager.Instance.PlaySlashSound();
        }
        else if (action.Name == "Super Slash")
        {
            SoundManager.Instance.PlaySlash2Sound();
        }
        else if (action.Name == "Hyper Slash")
        {
            SoundManager.Instance.PlaySlash3Sound();
        }

		var targets = Physics2D.OverlapAreaAll ( point0, point1, punchLayer.value );
		bool flag = false;
		foreach ( var target in targets )
		{
			var player = target.GetComponentInParent<Player> ();
			if ( player != null && player != owner )
			{
				flag |= ExecuteAction ( owner, action, player );
			}
		}
		if ( !flag )
		{
			ExecuteAction ( owner, action, null );
		}
		return flag;
	}

        public override Node AdvanceHead(PlayerAction action)
        {
            Assert.That(action == PlayerAction.Call || action == PlayerAction.Fold);

            if (action == PlayerAction.Call) return CallBranch;
            else return null;
        }

 public void playerDid(PlayerAction pa)
 {
     handlePlayerDid(pa);
     updateState();
     if (Vector3.Distance(transform.position, playeractions.transform.position) < cosyProximity && !sceneFinished)
     {
         switch (state)
         {
             case DateState.HAPPY:
                 print("WE WIN!");
                 playeractions.Win();
                 sceneFinished = true;
                 StartCoroutine(WaitAndProgress(3));
                 break;
             case DateState.NORMAL:
                 Debug.Log("NOOOP");
                 transform.Translate(jumpAwayDistance, 0, 0);
                 break;
             case DateState.UNHAPPY:
                 print("WE LOSE!");
                 playeractions.Lose();
                 transform.Translate(0, 1000, 0);
                 break;
         }
     }
 }

 public PlayerActions()
 {
     Left = CreatePlayerAction( "Move Left" );
     Right = CreatePlayerAction( "Move Right" );
     Jump = CreatePlayerAction( "Jump" );
     Shift = CreatePlayerAction ("Kinetic Shift");
     Move = CreateOneAxisPlayerAction (Left, Right);
 }

        public static IndentedTextWriter GetGameLogWriterForIteration(PlayerAction[] playerActions, int gameCount)
        {
            string fileName = GetFileNameForType(playerActions, gameCount, "GameLog");

            if (fileName == null)
                return null;
            return new IndentedTextWriter(new System.IO.StreamWriter(fileName));
        }

 public ControlsActionSet()
 {
     Down = CreatePlayerAction ("Move Down");
     Left = CreatePlayerAction ("Move Left");
     Right = CreatePlayerAction ("Move Right");
     Up = CreatePlayerAction ("Move Up");
     Tap = CreatePlayerAction ("Tap");
 }

        public static float GetAccelerationFactor(PlayerAction action, CarBehaviour carObj)
        {
            if (action == PlayerAction.SpeedUp)
            {
                return carObj.Speed < 0 ? 10 : 5;
            }

            return action == PlayerAction.SpeedDown ? (carObj.Speed < 0 ? 10 : 50) : 0;
        }

	public override void handlePlayerDid(PlayerAction pa) {
		switch(pa) {
			case PlayerAction.BACKOFF:
			case PlayerAction.MOVE_FORWARD:
				happyness -= loosingOnMove;
				happyness = Mathf.Max(0, happyness);
				break;
		}
	}

        public static float GetAccelerationIncrease(PlayerAction action)
        {
            if (action == PlayerAction.SpeedUp)
            {
                return GameData.ACCELERATION_INCREASE;
            }

            return action == PlayerAction.SpeedDown ? GameData.ACCELERATION_DECREASE : 0;
        }