Ejemplo n.º 1
0
        private void Update()
        {
            var frozen =
                _animator.GetBool(PlayerFSMData.Stat.Frozen) ||
                _mover.CurrentMovingState == MovingState.Dash ||
                _mover.PullDelaying ||
                _weaponSystem.Frozen;

            SetFrozen(frozen);

            _input.DelayInput = _animator.GetBool(PlayerFSMData.Stat.DelayInput);
            _input.BlockInput = _mover.BlockInput || _animator.GetBool(PlayerFSMData.Stat.BlockInput);

            var moveInput = _state._frozen ? Vector2.zero : _input.GetMovingDirection().normalized;

            if (moveInput.x != 0)
            {
                moveInput = DirectionalHelper.NormalizeHorizonalDirection(moveInput);
            }
            _mover.Move(moveInput);

            if (_state._frozen)
            {
                _animator.SetFloat(PlayerFSMData.Stat.XSpeed, 0);
                _animator.SetFloat(PlayerFSMData.Stat.YSpeed, _mover.Velocity.y);
            }
            else
            {
                _animator.SetFloat(PlayerFSMData.Stat.XSpeed, moveInput.x);
                _animator.SetFloat(PlayerFSMData.Stat.YSpeed, _mover.Velocity.y);
                UpdateFacingDirection(moveInput);
            }

            HandleEndurance();
        }
        Vector2 NormalizeHorizonalDirection(Vector2 direction)
        {
            if (direction.x == 0)
            {
                return(_state._facingRight ? Vector2.right : Vector2.left);
            }

            return(DirectionalHelper.NormalizeHorizonalDirection(direction));
        }
Ejemplo n.º 3
0
        private void HandleReceivedInput(InputEventArg <PlayerInputCommand> input)
        {
            var     pInput          = _input as PlayerInput;
            Vector2 aimingDirection = pInput.GetAimingDirection();

            switch (input._command)
            {
            // Normal jump. If player is on ground, jump away without holding the jump button
            case PlayerInputCommand.JumpBegin:
                if (!_groundDetector.IsOnGround)
                {
                    break;
                }
                CancelAnimation();
                _mover.Jump();
                _animator.SetToggle(PlayerFSMData.Stat.Jump, true);
                break;

            // Extra jump only happens here, normal jump could happen too if player is on ground.
            case PlayerInputCommand.Jump:
                if (!_groundDetector.IsOnGround &&
                    !_extraJump)
                {
                    break;
                }

                CancelAnimation();
                if (_extraJump)
                {
                    _mover.ExtraJump(input._additionalValue);
                    _extraJump = false;
                }
                else
                {
                    _mover.Jump();
                }

                TriggerBulletTimeIfPossible();
                _animator.SetToggle(PlayerFSMData.Stat.Jump, true);
                break;

            // Dash. Both ground and air dash.
            case PlayerInputCommand.Dash:
                if (!_dashCooldownTimer.IsReachedTime())
                {
                    return;
                }

                // Determine the dashing direction
                var dashingDirection = _input.GetMovingDirection();
                if (dashingDirection == Vector2.zero)
                {
                    dashingDirection = _state._facingRight ? Vector2.right : Vector2.left;
                }
                else
                {
                    dashingDirection = DirectionalHelper.NormalizeOctadDirection(dashingDirection);
                }

                UpdateFacingDirection(dashingDirection);

                var airDash = !_groundDetector.IsOnGround || dashingDirection.y > 0;

                // Break if this dash cannot happen
                if (airDash && _state._stamina <= 0)
                {
                    break;
                }

                _airDashGhost.enabled    = airDash;
                _groundDashGhost.enabled = !airDash;

                CancelAnimation();
                _mover.Dash(dashingDirection);

                if (airDash)
                {
                    _state._stamina  -= 1;
                    _currentAirAttack = 0;
                    TriggerBulletTimeIfPossible();

                    _extraJump       = true;
                    _bulletTimeReady = true;
                    _btManager.StartDashBTWindow();
                }
                else
                {
                    _dashCooldownTimer.Start(_dashCooldown);
                }

                _animator.SetToggle(PlayerFSMData.Stat.DashBegin, true);
                _animator.SetFloat(PlayerFSMData.Stat.XSpeed, dashingDirection.x);
                _animator.SetFloat(PlayerFSMData.Stat.YSpeed, dashingDirection.y);
                SetBlockInput(true);
                SetFrozen(true);

                _animator.UpdateAnimationState();
                break;

            //case PlayerInputCommand.MeleeBegin:
            //    if (!_groundDetector.IsOnGround && _currentAirAttack >= _maxAirAttack)
            //        break;
            //    CancelAnimation();
            //    break;

            // Both air melee and ground melee
            case PlayerInputCommand.MeleeAttack:
                if (!_groundDetector.IsOnGround && _currentAirAttack >= _maxAirAttack)
                {
                    break;
                }

                // Counting air attack
                if (!_groundDetector.IsOnGround)
                {
                    _currentAirAttack++;
                }

                _animator.SetToggle(PlayerFSMData.Stat.MeleeAttack, true);
                _mover.AirAttacking = !_groundDetector.IsOnGround;
                SetDelayInput(true);
                SetFrozen(true);

                TriggerBulletTimeIfPossible();
                break;

            //case PlayerInputCommand.MeleeChargeBegin:
            //    CancelAnimation();
            //    _animator.SetBool(PlayerFSMData.Stat.Charge, true);
            //    SetFrozen(true);

            //    TriggerBulletTimeIfPossible();
            //    break;

            //case PlayerInputCommand.MeleeChargeBreak:
            //    CancelAnimation();
            //    _animator.SetBool(PlayerFSMData.Stat.Charge, false);
            //    break;

            //case PlayerInputCommand.MeleeChargeAttack:
            //    _weaponSystem.ChargedMeleeAttack(input._additionalValue);
            //    _animator.SetToggle(PlayerFSMData.Stat.MeleeAttack, true);
            //    SetDelayInput(true);
            //    SetFrozen(true);
            //    break;

            case PlayerInputCommand.RangeBegin:
                _weaponSystem.StartRangeCharge(input._actionChargedPercent);
                _aimAssistant.StartAimingAssistant();
                break;

            case PlayerInputCommand.RangeAttack:
                if (!pInput.IsUsingController)
                {
                    _weaponSystem.RangeAttack(aimingDirection);
                    break;
                }

                if (aimingDirection.sqrMagnitude <= 0.025f)
                {
                    aimingDirection = _aimAssistant.ToNearestTarget(_state._facingRight);
                }
                else
                {
                    aimingDirection = _aimAssistant.ExcuteAimingAssistantance(aimingDirection);
                }
                _weaponSystem.RangeAttack(aimingDirection);
                break;

            case PlayerInputCommand.RangeChargeBreak:
                _weaponSystem.StopCharging();
                break;

            case PlayerInputCommand.RangeChargeAttack:
                if (!pInput.IsUsingController)
                {
                    _weaponSystem.ChargedRangeAttack(aimingDirection);
                    break;
                }

                if (aimingDirection.sqrMagnitude <= 0.025f)
                {
                    aimingDirection = _aimAssistant.ToNearestTarget(_state._facingRight);
                }
                else
                {
                    aimingDirection = _aimAssistant.ExcuteAimingAssistantance(aimingDirection);
                }
                _weaponSystem.ChargedRangeAttack(aimingDirection);
                break;

            case PlayerInputCommand.WithdrawAll:
                TriggerBulletTimeIfPossible();
                _weaponSystem.WithdrawAll();
                break;

            case PlayerInputCommand.WithdrawOne:
                TriggerBulletTimeIfPossible();
                _weaponSystem.WithdrawOne();
                break;

            case PlayerInputCommand.Regenerate:
                if (_state._stamina < _healingStaminaCost)
                {
                    break;
                }
                _animator.SetToggle(PlayerFSMData.Stat.Healing, true);
                SetBlockInput(true);
                SetFrozen(true);
                break;
            }
        }