// Update is called once per frame
void Update()
{
// Check if the character is dead
if (HealthComp.IsDead && !HealthComp.Respawning)
{
HealthComp.Respawning = true;
gameObject.GetComponent <ParticleSystem>().Play();
this.LifeState = CharacterLifeState.Leafy_Dead;
this.audioSource.PlayOneShot(deathSound);
ResetLeafyAtCheckpoint();
}
if (!HealthComp.IsDead && HealthComp.Damaged)
{
this.LifeState = CharacterLifeState.Leafy_Tired;
}
if (!HealthComp.Damaged && !HealthComp.IsDead)
{
this.LifeState = CharacterLifeState.Leafy_Idle;
}
MovementState = moveController.MovementState;
// Set appropriate sprites
this.GetComponent <CharacterLifeSpriteController>().SetState(LifeState);
this.GetComponent <MovementSpriteController>().SetState(MovementState);
}
private void SetRunning(CharacterMovementState _movState)
{
if (_movState != actualMovState)
{
maxXSpeed = runningMaxXSpeed;
actualMovState = _movState;
SetAnimState("running", true);
}
}
private void SetRunning(CharacterMovementState _action)
{
if (npcStateAction != CharacterMovementState.Running || maxXSpeed < 1.1f)
{
maxXSpeed = maxRunX;
}
SetAnimState("running", true);
npcStateAction = _action;
}
public void SetState(CharacterMovementState state)
{
if (SpriteLibrary.ContainsKey(state))
{
currentState = state;
renderer.sprite = SpriteLibrary[state];
this.GetComponentInParent<SpriteRenderer>().sprite = SpriteLibrary[state];
}
}
private void SetInitialVariables()
{
actualMovState = CharacterMovementState.Idle;
pJumpState = CharacterJumpState.Grounded;
cDirector = FindObjectOfType <CameraDirector>();
playerSizeX = SetPlayersizeX();
playerSizeY = SetPlayerSizeY();
groundDistance = playerSizeY / 2 + .02f;
maxXSpeed = initialMaxSpeed;
}
private void SetWalking(CharacterMovementState _action)
{
if (npcStateAction != _action || maxXSpeed != initialMaxSpeed)
{
maxXSpeed = initialMaxSpeed;
}
SetAnimState("walking", true);
npcStateAction = _action;
}
protected virtual void SetInitialVariables()
{
npcStateAction = CharacterMovementState.Idle;
rBody = GetComponent <Rigidbody2D>();
npcAnim = GetComponent <Animator>();
spriteRender = GetComponent <SpriteRenderer>();
npcSizeX = SetPlayersizeX();
npcSizeY = SetPlayerSizeY();
groundDistance = npcSizeX / 2 + .03f;
maxJumpAmount = 1;
initialMaxSpeed = maxXSpeed;
}
public void ReceiveHorizontalInput(CharacterMovementState _movState, Vector2 _horizontalInput)
{
if (_horizontalInput.x > 0 && !lookingRight || _horizontalInput.x < 0 && lookingRight)
{
cDirector.PlayerChangedDirection();
ResetDirectionX(); //Check whatItDoes{
ResetAcceleration();
}
if (_movState != actualMovState)
{
SetIncomingState(_movState);
}
}
private void CheckMovementStateReceived(CharacterMovementState _action)
{
switch (_action)
{
case CharacterMovementState.Running:
SetRunning(_action);
break;
case CharacterMovementState.Walking:
SetWalking(_action);
break;
case CharacterMovementState.Idle:
SetIdle(_action);
break;
}
}
public void SetIncomingState(CharacterMovementState _movState)
{
switch (_movState)
{
case CharacterMovementState.Walking:
SetWalking(_movState);
break;
case CharacterMovementState.Running:
SetRunning(_movState);
break;
case CharacterMovementState.Idle:
SetIdle(_movState);
break;
}
}
private void PressHorizontalInput(InputAction.CallbackContext context)
{
Vector2 pMovement = context.ReadValue<Vector2>();
if (pMovement != Vector2.zero)
{
pActualMovState = CharacterMovementState.Walking;
pController.ReceiveHorizontalInput(pActualMovState, pMovement);
}
if (CheckPlayerHorizontalMove(pMovement))
{
/*if (PlayerIsRunning())
{
pActualMovState = CharacterMovementState.Running;
}
else if (PlayerIsRunning() == false)
{
pActualMovState = CharacterMovementState.Walking;
}
*/
}
else
{
if (pController.GetPlayerMovState() != CharacterMovementState.Idle)
{
pActualMovState = CharacterMovementState.Idle;
pController.SetIncomingState(pActualMovState);
}
}
}
/// <summary>
/// Update the state of the character
/// </summary>
private void UpdateState()
{
_state = CharacterMovementState.Idle;
if (Mathf.Abs(_currentVelocity.x) >= .1)
{
_state = CharacterMovementState.Run;
}
if (IsJumping)
{
_state = CharacterMovementState.Jump;
}
if (IsDashing)
{
_state = CharacterMovementState.Dash;
}
if (_currentVelocity.y <= -.1f)
{
_state = CharacterMovementState.Fall;
}
if (_wallGrab && !_coll.OnGround)
{
if (_currentVelocity.y > 0f)
{
_state = CharacterMovementState.WallRun;
}
else
{
_state = CharacterMovementState.WallSlide;
}
}
}
void Awake()
{
MovementState = CharacterMovementState.Idle;
StatusEffects = new List <StatusEffectRendering>();
isPlayer = gameObject.CompareTag("Player");
}
// Update is called once per frame
void Update()
{
var rigidBody = GetComponent <Rigidbody2D>();
var acceleration = 0f;
if (rigidBody.velocity == Vector2.zero)
{
this.MovementState = CharacterMovementState.Idle;
}
else
{
this.MovementState = CharacterMovementState.Walking;
}
if (rigidBody.velocity.y != 0)
{
var jumpComp = this.GetComponent <JumpController>();
if (jumpComp == null || !jumpComp.isJumping)
{
this.MovementState = CharacterMovementState.Bouncing;
}
if (jumpComp != null && jumpComp.isJumping)
{
this.MovementState = CharacterMovementState.Jumping;
}
}
if (Input.GetKey(LeftShift))
{
this.MovementState = CharacterMovementState.Running;
MaxAcceleration = 50f;
}
else
{
MaxAcceleration = 25f;
}
if (Input.GetKey(LeftKey) || CrossPlatformInputManager.GetAxis("Horizontal") < 0)
{
acceleration = -MaxAcceleration;
this.Orientation = Orientation.Left;
if (rigidBody.velocity.x > 0)
{
acceleration = -MaxAcceleration;
}
PreviousKey = LeftKey;
}
else if (Input.GetKey(RightKey) || CrossPlatformInputManager.GetAxis("Horizontal") > 0)
{
acceleration = MaxAcceleration;
this.Orientation = Orientation.Right;
if (rigidBody.velocity.x < 0)
{
acceleration = MaxAcceleration;
}
PreviousKey = RightKey;
}
else
{
acceleration = 0;
}
if (rigidBody.velocity.magnitude < 50f)
{
rigidBody.AddForce(Vector2.right * acceleration, ForceMode2D.Force);
}
}
private void SetIdle(CharacterMovementState _action)
{
npcStateAction = _action;
SetAnimState("idle", true);
}
void Awake()
{
//SetMatchPlayers();
pController = FindObjectOfType<PlayerController>();
pActualMovState = pController.GetPlayerMovState();
}
protected void MovementUpdate(float delta)
{
Vector3 v;
void MoveCharacter(float s)
{
switch (movementSettings.moveType)
{
case MovementSettings.MovementType.Accelerate:
v = Body.Velocity;
float a = movementSettings.accel * delta;
v.x += move.x * a;
v.z += move.y * a;
if (v.magnitude > s)
{
v = v.normalized * s;
}
Body.SetPlaneVelocity(v.x, v.z);
break;
case MovementSettings.MovementType.Immediate:
Body.SetPlaneVelocity(move.x * s, move.y * s);
break;
case MovementSettings.MovementType.Continuous:
Body.SetPlaneVelocity(move.x * s, move.y * s);
break;
case MovementSettings.MovementType.Tank:
Body.SetPlaneVelocity(move.x * s, move.y * s);
break;
default:
break;
}
}
void DragCharacter(float drag)
{
if (Body.Grounded)
{
if (Body.Speed < movementSettings.moveDeadzone)
{
Body.Freeze();
}
else
{
switch (movementSettings.moveType)
{
case MovementSettings.MovementType.Accelerate:
Body.Drag(drag * delta);
break;
case MovementSettings.MovementType.Immediate:
Body.Drag(drag * delta);
break;
case MovementSettings.MovementType.Continuous:
break;
case MovementSettings.MovementType.Tank:
Body.Drag(drag * delta);
break;
default:
break;
}
}
}
}
void Gravity()
{
v = Body.Velocity;
if (Body.Grounded)
{
v.y = Mathf.Lerp(v.y, 0, 0.1f);
}
else
{
v.y -= gravityForce * delta;
}
Body.Velocity = v;
}
switch (State)
{
case CharacterMovementState.Idle:
if (Body.GroundNormalAngle > movementSettings.maxSlope)
{
State = CharacterMovementState.Slide;
MovementUpdate(delta);
return;
}
DragCharacter(movementSettings.drag);
move.x = Body.Velocity.x / movementSettings.speed;
move.y = Body.Velocity.z / movementSettings.speed;
Gravity();
break;
case CharacterMovementState.Move:
MoveCharacter(movementSettings.speed);
Gravity();
break;
case CharacterMovementState.Sprint:
MoveCharacter(movementSettings.sprint);
Gravity();
break;
case CharacterMovementState.Slide:
v = Body.Velocity;
v = Vector3.ProjectOnPlane(v, Body.GroundNormal);
v.y -= gravityForce * delta;
Body.Velocity = v;
break;
case CharacterMovementState.Jump:
v = Body.Velocity;
switch (movementSettings.jumpType)
{
case MovementSettings.JumpType.Hold:
if (v.y > 0)
{
if (v.y < movementSettings.jump)
{
v.y += movementSettings.jumpAccel * Time.fixedDeltaTime;
}
else
{
State = CharacterMovementState.Idle;
}
}
else
{
v.y = movementSettings.jump / 2.0f;
}
break;
case MovementSettings.JumpType.Immediate:
if (Body.JumpGrounded)
{
v.y = movementSettings.jump;
}
break;
default:
break;
}
Body.Velocity = v;
break;
default:
break;
}
}
private void SetIdle(CharacterMovementState _movState)
{
actualMovState = _movState;
SetAnimState("idle", true);
}
private void SetWalking(CharacterMovementState _movState)
{
maxXSpeed = initialMaxSpeed;
actualMovState = _movState;
SetAnimState("walking", true);
}
public void ReceiveHorizontalMovement(CharacterMovementState incomingAction, bool rightDirection)
{
CheckMovementStateReceived(incomingAction);
CheckDirectionMovement(rightDirection);
}
private void PressRun(InputAction.CallbackContext context)
{
pActualMovState = CharacterMovementState.Running;
UpdatePlayerState();
}
