public PlayerState( PlayerStateMachine stateMachine, PlayerCharacter character, PlayerController controller )
{
this.stateMachine = stateMachine;
this.controller = controller;
this.character = character;
Actions = character.Input.Actions;
}
void Awake()
{
agent = GetComponent <NavMeshAgent> ();
enemyMask = LayerMask.GetMask ("Enemy");
thisCharacter = target;
capsuleCollider = GetComponent <CapsuleCollider> ();
psm = GetComponent <PlayerStateMachine> ();
}
void Awake()
{
anim = GetComponent <Animation> ();
anim[die].wrapMode = WrapMode.ClampForever; // faz com que a animaçao seja executada apenas uma vez.
anim[attack].wrapMode = WrapMode.Clamp;
pSM = GetComponent <PlayerStateMachine> ();
timeBetweenAttacks /= atkSpeed;
foreach (AnimationState state in anim) {
state.speed = animSpeed;
}
anim[attack].speed = atkSpeed;
}
public PlayGameState( GameStateMachine stateMachine )
: base(stateMachine)
{
foreach( UIView v in UIManager.Instance.Views )
{
if( v is GameView )
{
view = v as GameView;
}
}
playerStateMachine = GameObject.FindObjectOfType<PlayerStateMachine>() as PlayerStateMachine;
environmentStateMachine = GameObject.FindObjectOfType<EnvironmentStateMachine>() as EnvironmentStateMachine;
}
public MainMenuGameState( GameStateMachine stateMachine )
: base(stateMachine)
{
foreach( UIView v in UIManager.Instance.Views )
{
if( v is MainMenu )
{
view = v as MainMenu;
}
}
playerController = GameObject.FindObjectOfType<PlayerController>() as PlayerController;
playerStateMachine = GameObject.FindObjectOfType<PlayerStateMachine>() as PlayerStateMachine;
environmentStateMachine = GameObject.FindObjectOfType<EnvironmentStateMachine>() as EnvironmentStateMachine;
initialPlayerPosition = playerController.transform.position;
initialPlayerRotation = playerController.transform.rotation;
}
public PlayerState( PlayerStateMachine stateMachine )
: base()
{
this.stateMachine = stateMachine;
}
public void End(PlayerStateMachine owner)
{
bubble.Destory();
}
public PlayerState_IdlePose(PlayerStateMachine owner, GameMatch match) : base(owner, match)
{
m_eState = State.eIdlePose;
}
public PlayerInAirState(PlayerStateMachine stateMachine, Player player, int animCode, D_PlayerStateMachine data) : base(stateMachine, player, animCode, data)
{
}
// Update is called once per frame
void Update()
{
if (Input.GetButtonDown("Cancel"))
{
canvas.Back();
}
if (Enemies.Count <= 0)
{
battleStates = PerformAction.END;
}
//Main game logic state machine
switch (battleStates)
{
//"Waiting State" Waiting until one of the entities wants to do an action
case (PerformAction.WAIT):
if (PerformList.Count > 0)
{
battleStates = PerformAction.TAKEACTION;
}
break;
//Performing an action
case (PerformAction.TAKEACTION):
//Grabs first waiting entity
GameObject currentActionObject = PerformList.Dequeue().gameObject;
//Set the Entity State Machine to ACTION. TODO: Have EnemyStateMachine and PlayerStateMachine both derive from the same class.
if (currentActionObject.tag == "Enemy")
{
EnemyStateMachine ESM = currentActionObject.GetComponent <EnemyStateMachine>();
ESM.currentState = EnemyStateMachine.CurrentState.ACTION;
}
else if (currentActionObject.tag == "Hero")
{
PlayerStateMachine PSM = currentActionObject.GetComponent <PlayerStateMachine>();
PSM.currentState = PlayerStateMachine.CurrentState.ACTION;
}
battleStates = PerformAction.PERFORMACTION;
break;
//Another waiting state, waiting until entity has finished action and set this state back to WAIT.
case (PerformAction.PERFORMACTION):
break;
// Battle is over
case (PerformAction.END):
canvas.ShowWinText();
break;
}
//Player UI handling state machine
switch (playerUIStates)
{
//Waiting until a hero wants to use the UI
case (PlayerUIAction.WAIT):
if (HeroChoiceList.Count > 0)
{
playerUIStates = PlayerUIAction.PREPARING;
}
break;
//Player wants to use UI, setting up UI with player data
case (PlayerUIAction.PREPARING): //setup boxes and selectors
PlayerStateMachine currentActivePlayer = HeroChoiceList.Dequeue();
canvas.EnablePlayerBox(currentActivePlayer);
playerUIStates = PlayerUIAction.CHOOSING;
break;
//Player is currently awaiting input.
case (PlayerUIAction.CHOOSING):
break;
}
}
// Use this for initialization
void Start()
{
player = GameObject.FindObjectOfType <PlayerStateMachine> ();
thisCamera = GetComponent <Camera> ();
}
public void Begin(PlayerStateMachine owner)
{
bubble = SpeechBubbleManager.instance.CreateBubble(0, Localization.GetString("attack"));
bubble.Attach(owner.transform);
bubble.SetEffect(SpeechBubble.Effect.None);
}
public override void Update(PlayerStateMachine player)
{
player.debugState = "CLIMB";
}
public PlayerJoiningState(PlayerStateMachine playerStateMachine)
{
// TODO: Complete member initialization
this.playerStateMachine = playerStateMachine;
}
// private bool crouchInput;
public PlayerGroundedState(Player player, PlayerStateMachine stateMachine, string animBoolName) : base(player, stateMachine, animBoolName)
{
}
public IdlePlayerState(PlayerStateMachine fsm, PlayerController playerController, string animatorBool) : base(fsm, playerController, animatorBool)
{
}
//Enables player box with player data
public void EnablePlayerBox(PlayerStateMachine PSM)
{
activePlayer = PSM;
playerAction = new PlayerAction();
PlayerBox.EnablePlayerBox(PSM, this);
}
public PlayerUndoAcceptedState(PlayerStateMachine playerStateMachine)
{
// TODO: Complete member initialization
this.playerStateMachine = playerStateMachine;
}
public PlayerState_PractiseLayupDunk_Stand(PlayerStateMachine owner, GameMatch match) : base(owner, match)
{
m_eState = State.eStand;
m_validStateTransactions.Add(Command.Block);
}
//This is the state for when the player is in the air and moving downwards and forwards against a climbable object
public override void EnterState(PlayerStateMachine player)
{
player.playerVelocity.y = Mathf.Sqrt(player.playerJumpSpeed * 3f * player.playerGravity);
player.ChangeState(player.STATE_AIR);
}
void Awake()
{
psm = GetComponent <PlayerStateMachine> ();
}
public PlayerInitializingState(PlayerStateMachine playerMachine)
{
this.playerMachine = playerMachine;
}
public PlayerJumpState(Player player, PlayerStateMachine stateMachine, PlayerData playerData, string animBoolName) : base(player, stateMachine, playerData, animBoolName)
{
amountOfJumpsLeft = playerData.amountOfJumps;
}
//This is the state for when the player is grounded, not touching any movement keys, and is not crouching
public override void EnterState(PlayerStateMachine player)
{
}
public PlayerState(PlayerActor player, PlayerStateMachine psm)
{
this.Player = player;
this.psm = psm;
}
public PlayerClimbState(PlayerStateMachine currentContext, PlayerStateFactory playerStateFactory)
: base(currentContext, playerStateFactory)
{
}
public PlayerNormalSt(PlayerActor player, PlayerStateMachine psm) : base(player, psm)
{
}
//Used when a hero wants to use the UI, gets put into queue.
public void CollectUIPlayerActions(PlayerStateMachine PSM)
{
HeroChoiceList.Enqueue(PSM);
}
public PlayerGhostSt(PlayerActor player, PlayerStateMachine psm) : base(player, psm)
{
}
public PlayerIdleState(PlayerStateMachine machine) : base(machine)
{
}
public PlayerCrouchMoveState(Player player, PlayerStateMachine stateMachine, PlayerData playerData, string animBoolName) : base(player, stateMachine, playerData, animBoolName)
{
}
public override void Awake()
{
base.Awake();
Player = FindObjectOfType <PlayerStateMachine>();
}
public IdleState(Player player, PlayerStateMachine stateMachine) : base(player, stateMachine)
{
}
public PlayerEndFallState(Player player, PlayerStateMachine stateMachine, PlayerData playerData, string animBoolName) : base(player, stateMachine, playerData, animBoolName)
{
}
public PlayerGroundedState(PlayerController player, PlayerStateMachine stateMachine, PlayerData playerData, string animName) : base(player, stateMachine, playerData, animName)
{
this.stateName = StateNames.Grounded;
}
public AwkwardConversation (PlayerStateMachine _player, AwkwardPerson _person/*, int _stress*/)
{
player = _player;
awkward_person = _person;
// stress_to_give = _stress;
}
public PlayerInAirState(Player player, PlayerStateMachine stateMachine, PlayerData playerData, string boolName) : base(player, stateMachine, playerData, boolName)
{
}
public PlayerInGameState( PlayerStateMachine stateMachine )
: base(stateMachine)
{
}
public PlayerWallSlideState(Player player, PlayerStateMachine stateMachine, string animBoolName) : base(player, stateMachine, animBoolName)
{
}
public PlayerDeadState( PlayerStateMachine stateMachine )
: base(stateMachine)
{
environmentStateMachine = GameObject.FindObjectOfType<EnvironmentStateMachine>() as EnvironmentStateMachine;
gameStateMachine = GameObject.FindObjectOfType<GameStateMachine>() as GameStateMachine;
}
public PlayerGround(PlayerStateMachine playerStateMachine) : base(playerStateMachine)
{
}
public PlayerCrouchIdleState(PlayerController2D player, PlayerStateMachine stateMachine, PlayerData data, int animationHash) : base(player, stateMachine, data, animationHash)
{
}
private void Start()
{
mStateMachine = GetComponent <PlayerStateMachine>();
mCameraController = GetComponent <PlayerCameraController>();
}
public PlayerIdleState( PlayerStateMachine stateMachine, PlayerCharacter character, PlayerController controller )
: base(stateMachine, character, controller)
{
}
void Awake()
{
agent = GetComponent <NavMeshAgent> ();
playerMask = LayerMask.GetMask ("Player");
psm = GetComponent <PlayerStateMachine> ();
}