Beispiel #1
0
        // Aim will determine which direction the player in inputting to aim in
        public string Aim()
        {
            keyState = Keyboard.GetState();

            if (keyState.IsKeyDown(Keys.Up))
            {
                aimDirection = AimDirection.Up;
                return("up");
            }
            if (keyState.IsKeyDown(Keys.Right))
            {
                aimDirection = AimDirection.Forward;
                return("right");
            }
            if (keyState.IsKeyDown(Keys.Left))
            {
                aimDirection = AimDirection.Forward;
                return("left");
            }
            if (keyState.IsKeyDown(Keys.Up) && keyState.IsKeyDown(Keys.Right))
            {
                aimDirection = AimDirection.Diagonal;
                return("diagonal right");
            }
            if (keyState.IsKeyDown(Keys.Up) && keyState.IsKeyDown(Keys.Left))
            {
                aimDirection = AimDirection.Diagonal;
                return("diagonal left");
            }
            else
            {
                return(null);
            }
        }
Beispiel #2
0
 // note this currently only calculates with mouse input. For Controller support, will need
 // to process Aim Direction differently
 private Vector2 CalculateAimDirection()
 {
     AimDirection = _camera.ScreenToWorldPoint(_input.MousePosition) - transform.position;
     AimDirection.Normalize();
     Debug.Log("AimDirection: " + AimDirection);
     return(AimDirection);
 }
Beispiel #3
0
        public void Start()
        {
            AimDirection direction = physics.GetVelocityRef().ClosestDirection();

            // going left?
            bool flipX = direction == AimDirection.LEFT || direction == AimDirection.UP_LEFT ||
                         direction == AimDirection.DOWN_LEFT;

            switch (direction)
            {
            case AimDirection.UP:
                animator.SetBool(Up, true);
                break;

            case AimDirection.DOWN:
                animator.SetBool(Down, true);
                break;

            case AimDirection.UP_LEFT:
            case AimDirection.UP_RIGHT:
                animator.SetBool(DiagUp, true);
                break;

            case AimDirection.DOWN_LEFT:
            case AimDirection.DOWN_RIGHT:
                animator.SetBool(DiagDown, true);
                break;

            default:
                animator.SetBool(Horizontal, true);
                break;
            }

            spriteRenderer.flipX = flipX;
        }
Beispiel #4
0
    public void Update()
    {
        float aimX = Input.GetAxis("Aim X");
        float aimY = Input.GetAxis("Aim Y");

        bool hasGamepad = Input.GetJoystickNames().Length != 0 &&
                          Input.GetJoystickNames().Any(x => x.Length != 0);

        if (Controls.UseMouseToAim && !hasGamepad)
        {
            Vector3 mouseInWorld = camera.ScreenToWorldPoint(Input.mousePosition);
            aimX = mouseInWorld.x - transform.position.x;
            aimY = mouseInWorld.y - transform.position.y;
        }

        aimVector.x = aimX;
        aimVector.y = aimY;

        AimDirection aimDirection = aimVector.ClosestDirection();

        if (aimDirection != AimDirection.LAST)
        {
            direction = aimDirection;
        }
    }
Beispiel #5
0
        /**
         * Get the angle corresponding to this aim direction
         * Returns NaN for AimDirection.LAST
         */
        public static float Angle(this AimDirection direction)
        {
            if (direction == AimDirection.LAST)
            {
                return(float.NaN);
            }

            return((int)direction * anglePerSection);
        }
        private void Update()
        {
            AimDirection aim = physics.GetVelocityRef().ClosestDirection();

            if (aim != AimDirection.LAST)
            {
                direction = aim;
            }
        }
Beispiel #7
0
        // constructor
        public Player(Rectangle hBox, Texture2D texture) : base(hBox, texture)
        {
            keyState     = new KeyboardState();
            aimDirection = AimDirection.Forward;
            speedX       = 5;
            speedY       = 0;

            // set rectangles for collsion detection
            leftSide   = new Rectangle(hitBox.X, hitBox.Y, -3, hitBox.Height);
            rightSide  = new Rectangle((hitBox.X + hitBox.Width), hitBox.Y, 3, hitBox.Height);
            topSide    = new Rectangle(hitBox.X, hitBox.Y, hitBox.Width, -3);
            bottomSide = new Rectangle(hitBox.X, (hitBox.Y + hitBox.Height), hitBox.Width, 3);
        }
    public float GetAngleForDirection(AimDirection checkDir)
    {
        switch (checkDir)
        {
        case AimDirection.eAimDirectionN:
        {
            return(0f);
        }

        case AimDirection.eAimDirectionNE:
        {
            return(-45f);
        }

        case AimDirection.eAimDirectionNW:
        {
            return(45);
        }

        case AimDirection.eAimDirectionS:
        {
            return(180f);
        }

        case AimDirection.eAimDirectionSE:
        {
            return(-135f);
        }

        case AimDirection.eAimDirectionSW:
        {
            return(135f);
        }

        case AimDirection.eAimDirectionE:
        {
            return(-90f);
        }

        case AimDirection.eAimDirectionW:
        {
            return(90f);
        }

        default:
            return(0f);
        }
    }
Beispiel #9
0
 public void Update()
 {
     if (cooldown > 0)
     {
         cooldown -= Time.deltaTime;
     }
     if (ShouldShoot() && CanShoot())
     {
         AimDirection direction = aim.GetDirection();
         float        angle     = direction.Angle();
         float        cosangle  = Mathf.Cos(angle);
         float        sinangle  = Mathf.Sin(angle);
         SpawnBullet(angle, cosangle * speed, sinangle * speed);
         cooldown = shootCooldown;
     }
 }
	// Update is called once per frame
	void Update () {

        if( !rootObj )
        {
            rootObj = transform.root.gameObject;
            return;
        }

        switch(mSpriteSelType)
        {
            case SelectionType.eSelectionAim:
                {
                    PlayerAimController playerAimControl = rootObj.GetComponent<PlayerAimController>();
                    if( playerAimControl)
                    {
                        currentDirection = playerAimControl.GetAimDirection();
                    }
                    break;
                }
            case SelectionType.eSelectionMove:
                {
                    PlayerMoveController playerMove = rootObj.GetComponent<PlayerMoveController>();
                    if(playerMove)
                    {
                        currentDirection = playerMove.GetAimDirection();
                    }
                    break;
                }
        }
        if(m_directionalSprites.ContainsKey(currentDirection))
        {
            SpriteRenderer spriteRender = GetComponent<SpriteRenderer>();
            if(spriteRender)
            {
                SpriteSelection chosen = m_directionalSprites[currentDirection];
                spriteRender.sprite = chosen.spriteSelection;
            }
            
        }

        if(bVerboseLogging)
        {
            Debug.Log("Current direction :" + currentDirection.ToString());
        }
        
    }
    // Update is called once per frame
    void Update()
    {
        if (!rootObj)
        {
            rootObj = transform.root.gameObject;
            return;
        }

        switch (mSpriteSelType)
        {
        case SelectionType.eSelectionAim:
        {
            PlayerAimController playerAimControl = rootObj.GetComponent <PlayerAimController>();
            if (playerAimControl)
            {
                currentDirection = playerAimControl.GetAimDirection();
            }
            break;
        }

        case SelectionType.eSelectionMove:
        {
            PlayerMoveController playerMove = rootObj.GetComponent <PlayerMoveController>();
            if (playerMove)
            {
                currentDirection = playerMove.GetAimDirection();
            }
            break;
        }
        }
        if (m_directionalSprites.ContainsKey(currentDirection))
        {
            SpriteRenderer spriteRender = GetComponent <SpriteRenderer>();
            if (spriteRender)
            {
                SpriteSelection chosen = m_directionalSprites[currentDirection];
                spriteRender.sprite = chosen.spriteSelection;
            }
        }

        if (bVerboseLogging)
        {
            Debug.Log("Current direction :" + currentDirection.ToString());
        }
    }
 public float GetAngleForDirection( AimDirection checkDir )
 {
     switch( checkDir)
     {
         case AimDirection.eAimDirectionN:
             {
                 return 0f;
             }
         case AimDirection.eAimDirectionNE:
             {
                 return -45f;
             }
         case AimDirection.eAimDirectionNW:
             {
                 return 45;
             }
         case AimDirection.eAimDirectionS:
             {
                 return 180f;
             }
         case AimDirection.eAimDirectionSE:
             {
                 return -135f;
             }
         case AimDirection.eAimDirectionSW:
             {
                 return 135f;
             }
         case AimDirection.eAimDirectionE:
             {
                 return -90f;
             }
         case AimDirection.eAimDirectionW:
             {
                 return 90f;
             }
         default:
             return 0f;
     }
 }
Beispiel #13
0
    void Update()
    {
        if (player == null)
        {
            player = playerFinder.getPlayerTransform();
            AI.setbuttonHeldAimRight(true);
            AI.setbuttonHeldAimLeft(false);
            AI.setbuttonHeldAimUp(false);
            AI.setbuttonHeldAimDown(false);
            return;
        }

        if (player.position.x > transform.position.x && AISync.getFacingRight() == false)
        {
            aimLeft  = false;
            aimRight = true;
            AI.setbuttonHeldAimLeft(aimLeft);
            AI.setbuttonHeldAimRight(aimRight);
            AI.setbuttonHeldAimUp(aimUp);
            AI.setbuttonHeldAimDown(aimDown);
            return;
        }
        else if (player.position.x < transform.position.x && AISync.getFacingRight() == true)
        {
            aimRight = false;
            aimLeft  = true;
            AI.setbuttonHeldAimRight(aimRight);
            AI.setbuttonHeldAimLeft(aimLeft);
            AI.setbuttonHeldAimUp(aimUp);
            AI.setbuttonHeldAimDown(aimDown);
            return;
        }

        Vector3      playerPos       = player.transform.position - new Vector3(0, 5, 0);
        Vector2      origin          = new Vector2(0f, 0f); //Init
        Vector2      hitDirection    = new Vector2(0f, 0f); //Init
        AimDirection vectorDirection = 0;
        Quaternion   rotation;
        Vector2      direction;

        if (AISync.getFacingRight() == true)
        {
            if (player.position.y >= transform.position.y)
            {
                //Up
                aimUp   = true;
                aimDown = false;

                //Up
                rotation  = spawn4.rotation;
                rotation  = Quaternion.Euler(rotation.eulerAngles.x, rotation.eulerAngles.y, rotation.eulerAngles.z * -1);
                direction = rotation * Vector2.right;
                vector1   = direction * 50;
                vector2   = (playerPos - spawn4.position);
                angle1    = Vector3.Angle(vector1, vector2);
                Debug.DrawRay(spawn4.position, vector1, Color.yellow);
                Debug.DrawRay(spawn4.position, vector2, Color.white);
                angleEnum1 = AimDirection.Up;
                Up         = vector1;

                //Up Right
                rotation  = spawn3.rotation;
                rotation  = Quaternion.Euler(rotation.eulerAngles.x, rotation.eulerAngles.y, rotation.eulerAngles.z * -1);
                direction = rotation * Vector2.right;
                vector1   = direction * 50;
                vector2   = (playerPos - spawn3.position);
                angle2    = Vector3.Angle(vector1, vector2);
                Debug.DrawRay(spawn3.position, vector1, Color.yellow);
                Debug.DrawRay(spawn3.position, vector2, Color.white);
                angleEnum2 = AimDirection.UpRight;
                UpRight    = vector1;
            }
            else
            {
                //Down
                aimUp   = false;
                aimDown = true;

                //Down
                rotation  = spawn0.rotation;
                rotation  = Quaternion.Euler(rotation.eulerAngles.x, rotation.eulerAngles.y, rotation.eulerAngles.z * -1);
                direction = rotation * Vector2.right;
                Vector3 spawn0Pos = spawn0.position - v0_4_0;
                vector1 = direction * 50;
                vector2 = (playerPos - spawn0Pos);
                angle1  = Vector3.Angle(vector1, vector2);
                Debug.DrawRay(spawn0Pos, vector1, Color.yellow);
                Debug.DrawRay(spawn0Pos, vector2, Color.white);
                angleEnum1 = AimDirection.Down;
                Down       = vector1;

                //Down Right
                rotation  = spawn1.rotation;
                rotation  = Quaternion.Euler(rotation.eulerAngles.x, rotation.eulerAngles.y, rotation.eulerAngles.z * -1);
                direction = rotation * Vector2.right;
                vector1   = direction * 50;
                vector2   = (playerPos - spawn1.position);
                angle2    = Vector3.Angle(vector1, vector2);
                Debug.DrawRay(spawn1.position, vector1, Color.yellow);
                Debug.DrawRay(spawn1.position, vector2, Color.white);
                angleEnum2 = AimDirection.DownRight;
                DownRight  = vector1;
            }

            if (angle1 > angle2)
            {
                angle1          = angle2;
                vectorDirection = angleEnum2;
                aimRight        = true;
            }
            else
            {
                aimRight        = false;
                aimLeft         = false;
                vectorDirection = angleEnum1;
            }

            //Right
            vector1 = new Vector3(spawn2.position.x + 50, spawn2.position.y, 0) - spawn2.position;
            vector2 = (playerPos - spawn2.position);
            angle3  = Vector3.Angle(vector1, vector2);
            Debug.DrawRay(spawn2.position, new Vector3(50, 0, 0), Color.yellow);
            Debug.DrawRay(spawn2.position, vector2, Color.white);
            Right = vector1;

            if (angle1 > angle3)
            {
                angle1          = angle3;
                vectorDirection = AimDirection.Right;
                aimUp           = false;
                aimDown         = false;
            }

            // If the AI gets close to a target it'll aim up
            if (Mathf.Abs(transform.position.x - player.position.x) < 10f && Mathf.Abs(transform.position.y - player.position.y) < 3)
            {
                angle1          = angle3;
                vectorDirection = AimDirection.Right;
                aimUp           = false;
                aimDown         = false;
            }

            AI.setbuttonHeldAimRight(aimRight);
            AI.setbuttonHeldAimLeft(aimLeft);
            AI.setbuttonHeldAimUp(aimUp);
            AI.setbuttonHeldAimDown(aimDown);
        }
        else if (AISync.getFacingRight() == false)
        {
            if (player.position.y >= transform.position.y)
            {
                //Up
                aimUp   = true;
                aimDown = false;

                //Up
                rotation  = spawn4.rotation;
                rotation  = Quaternion.Euler(rotation.eulerAngles.x, rotation.eulerAngles.y, rotation.eulerAngles.z * -1);
                direction = rotation * Vector2.left;
                vector1   = direction * 50;
                vector2   = (playerPos - spawn4.position);
                angle1    = Vector3.Angle(vector1, vector2);
                Debug.DrawRay(spawn4.position, vector1, Color.yellow);
                Debug.DrawRay(spawn4.position, vector2, Color.white);
                angleEnum1 = AimDirection.Up;
                Up         = vector1;

                //Up Left
                rotation  = spawn3.rotation;
                rotation  = Quaternion.Euler(rotation.eulerAngles.x, rotation.eulerAngles.y, rotation.eulerAngles.z * -1);
                direction = rotation * Vector2.left;
                vector1   = direction * 50;
                vector2   = (playerPos - spawn3.position);
                angle2    = Vector3.Angle(vector1, vector2);
                Debug.DrawRay(spawn3.position, vector1, Color.yellow);
                Debug.DrawRay(spawn3.position, vector2, Color.white);
                angleEnum2 = AimDirection.UpLeft;
                UpLeft     = vector1;
            }
            else
            {
                //Down
                aimUp   = false;
                aimDown = true;

                //Down
                Vector3 spawn0Pos = spawn0.position - v0_4_0;
                rotation  = spawn0.rotation;
                rotation  = Quaternion.Euler(rotation.eulerAngles.x, rotation.eulerAngles.y, rotation.eulerAngles.z * -1);
                direction = rotation * Vector2.left;
                vector1   = direction * 50;
                vector2   = (playerPos - spawn0Pos);
                angle1    = Vector3.Angle(vector1, vector2);
                Debug.DrawRay(spawn0Pos, vector1, Color.yellow);
                Debug.DrawRay(spawn0Pos, vector2, Color.white);
                angleEnum1 = AimDirection.Down;
                Down       = vector1;

                //Down Left
                rotation  = spawn1.rotation;
                rotation  = Quaternion.Euler(rotation.eulerAngles.x, rotation.eulerAngles.y, rotation.eulerAngles.z * -1);
                direction = rotation * Vector2.left;
                vector1   = direction * 50;
                vector2   = (playerPos - spawn1.position);
                angle2    = Vector3.Angle(vector1, vector2);
                Debug.DrawRay(spawn1.position, vector1, Color.yellow);
                Debug.DrawRay(spawn1.position, vector2, Color.white);
                angleEnum2 = AimDirection.DownLeft;
                DownLeft   = vector1;
            }

            if (angle1 > angle2)
            {
                angle1          = angle2;
                vectorDirection = angleEnum2;
                aimLeft         = true;
            }
            else
            {
                aimRight        = false;
                aimLeft         = false;
                vectorDirection = angleEnum1;
            }

            //Left
            rotation  = spawn2.rotation;
            rotation  = Quaternion.Euler(rotation.eulerAngles.x, rotation.eulerAngles.y, rotation.eulerAngles.z * -1);
            direction = rotation * Vector2.left;
            vector1   = direction * 50;
            vector2   = (playerPos - spawn2.position);
            angle3    = Vector3.Angle(vector1, vector2);
            Debug.DrawRay(spawn2.position, vector1, Color.yellow);
            Debug.DrawRay(spawn2.position, vector2, Color.white);
            Left = vector1;

            if (angle1 > angle3)
            {
                angle1          = angle3;
                vectorDirection = AimDirection.Left;
                aimUp           = false;
                aimDown         = false;
            }

            // If the AI gets close to a target it'll aim up
            if (Mathf.Abs(transform.position.x - player.position.x) < 5f && Mathf.Abs(transform.position.y - player.position.y) < 3)
            {
                angle1          = angle3;
                vectorDirection = AimDirection.Left;
                aimUp           = false;
                aimDown         = false;
            }
            AI.setbuttonHeldAimRight(aimRight);
            AI.setbuttonHeldAimLeft(aimLeft);
            AI.setbuttonHeldAimUp(aimUp);
            AI.setbuttonHeldAimDown(aimDown);
        }

        if (vectorDirection == AimDirection.Up)
        {
            origin       = spawn4.position;
            hitDirection = Up;
        }
        else if (vectorDirection == AimDirection.Down)
        {
            origin       = spawn0.position - v0_4_0;
            hitDirection = Down;
        }
        else if (vectorDirection == AimDirection.UpRight)
        {
            origin       = spawn3.position;
            hitDirection = UpRight;
        }
        else if (vectorDirection == AimDirection.UpLeft)
        {
            origin       = spawn3.position;
            hitDirection = UpLeft;
        }
        else if (vectorDirection == AimDirection.DownRight)
        {
            origin       = spawn1.position;
            hitDirection = DownRight;
        }
        else if (vectorDirection == AimDirection.DownLeft)
        {
            origin       = spawn1.position;
            hitDirection = DownLeft;
        }
        else if (vectorDirection == AimDirection.Right)
        {
            origin       = spawn2.position;
            hitDirection = Right;
        }
        else if (vectorDirection == AimDirection.Left)
        {
            origin       = spawn2.position;
            hitDirection = Left;
        }
        Hit = Physics2D.Raycast(origin, hitDirection, 100f);

        if (Hit.transform == null || (Hit.transform != null && String.Compare(Hit.transform.name, 0, "Cube", 0, 4) == 0))
        {
            aimUp   = false;
            aimDown = false;
            AI.setbuttonHeldAimUp(aimUp);
            AI.setbuttonHeldAimDown(aimDown);
        }
    }
        public override void Update()
        {
            MoveDirection = Vector2.Zero;
            AimDirection  = Vector2.Zero;

            // Left stick: movement
            var padDirection = Input.GetLeftThumb(ControllerIndex);
            var isDeadZone   = padDirection.Length() < DeadZone;

            if (!isDeadZone)
            {
                MoveDirection = padDirection;
            }
            MoveDirection.Normalize();

            // Right stick: aim
            padDirection = Input.GetRightThumb(ControllerIndex);
            var aimSpeed = padDirection.Length();

            isDeadZone = aimSpeed < DeadZone;
            // Make sure aim starts at 0 when outside deadzone
            aimSpeed = (aimSpeed - DeadZone) / (1.0f - DeadZone);
            // Clamp aim speed
            if (aimSpeed > 1.0f)
            {
                aimSpeed = 1.0f;
            }
            // Curve aim speed
            aimSpeed = (float)Math.Pow(aimSpeed, 1.6);
            if (!isDeadZone)
            {
                AimDirection = padDirection;
                AimDirection.Normalize();
                AimDirection *= aimSpeed;
            }

            // Keyboard move
            if (KeysLeft.Any(key => Input.IsKeyDown(key)))
            {
                MoveDirection += -Vector2.UnitX;
            }
            if (KeysRight.Any(key => Input.IsKeyDown(key)))
            {
                MoveDirection += +Vector2.UnitX;
            }
            if (KeysUp.Any(key => Input.IsKeyDown(key)))
            {
                MoveDirection += +Vector2.UnitY;
            }
            if (KeysDown.Any(key => Input.IsKeyDown(key)))
            {
                MoveDirection += -Vector2.UnitY;
            }

            var isAiming      = KeysAim.Any(key => Input.IsKeyDown(key)) || Input.GetLeftTrigger(ControllerIndex) >= DeadZone;
            var isFiring      = KeysShoot.Any(key => Input.IsKeyDown(key)) || Input.GetRightTrigger(ControllerIndex) >= DeadZone;
            var isStarting    = KeysStart.Any(key => Input.IsKeyPressed(key)) || Input.IsGamePadButtonPressed(ControllerIndex, GamePadButton.Start);
            var isReloading   = KeysReload.Any(key => Input.IsKeyPressed(key)) || Input.IsGamePadButtonPressed(ControllerIndex, GamePadButton.Y);
            var isInteracting = KeysInteract.Any(key => Input.IsKeyPressed(key)) || Input.IsGamePadButtonPressed(ControllerIndex, GamePadButton.A);

            if (isStarting)
            {
                OnStart?.Invoke(Entity);
            }

            if (isReloading)
            {
                OnReload?.Invoke(Entity);
            }

            if (isInteracting)
            {
                OnInteract?.Invoke(Entity);
            }

            // Mouse aim (after normalization of aim direction)
            // mouse aim is only enabled after you click the screen to lock your cursor, pressing escape cancels this
            if (Input.IsMouseButtonDown(MouseButton.Left))
            {
                Input.LockMousePosition(true);
            }
            if (Input.IsKeyPressed(Keys.Escape))
            {
                Input.UnlockMousePosition();
            }
            if (Input.IsMousePositionLocked)
            {
                // Mouse shooting
                if (Input.IsMouseButtonDown(MouseButton.Left))
                {
                    isFiring = true;
                }

                // Mouse aiming
                if (Input.IsMouseButtonDown(MouseButton.Right))
                {
                    isAiming = true;
                }

                AimDirection += new Vector2(Input.MouseDelta.X, -Input.MouseDelta.Y) * MouseSensitivity;
            }

            if (InvertXAxis)
            {
                AimDirection = new Vector2(-AimDirection.X, AimDirection.Y);
            }
            if (InvertYAxis)
            {
                AimDirection = new Vector2(AimDirection.X, -AimDirection.Y);
            }

            AimState  = isAiming;
            FireState = isFiring;
        }
    // Update is called once per frame when our player object tells us to
    public void UpdateMovement () {

        if( !HotInputManager.sInstance )
        {
            return;
        }
        Vector3 newMov = HotInputManager.sInstance.GetMoveVector(mPlayerId);

        moveVector = Vector3.zero;

        moveHorizontal = newMov.x;
        moveVertical = newMov.y;

        bool bMoving = (moveHorizontal != 0f || moveVertical != 0f);

        if(momentumPercent > 0f || bMoving)
        {
            momentumPercent += (bMoving) ? (momentumSpeedUpRate * Time.deltaTime) : -(momentumSlowDownRate * Time.deltaTime);
        }
        
        momentumPercent = Mathf.Clamp01(momentumPercent);

        currentSpeed = momentumPercent * maxSpeed;

        moveVector.x = moveHorizontal;
        moveVector.y = moveVertical;

        moveVector = Vector3.Normalize(moveVector);

        float gameRadius = 50f;
        if( GameBounds.sBounds )
        {
            gameRadius = GameBounds.sBounds.GetGameRadius();
            Vector3 localPosition = transform.position;
            if( Vector3.Distance(Vector3.zero, localPosition + moveVector ) > gameRadius)
            {
                // Unless we're heading back in, we don't want to let the player go this way
                moveVector = Vector3.zero - localPosition;
            }
        }

        if( currentSpeed == 0f)
        {
            m_currentDirection = m_defaultDirection;
            if(m_movementAnim)
            {
                m_movementAnim.SetBool("IsMoving", false);
            }
        }
        else
        {
            m_currentDirection = GetAimDirection();
            if (m_movementAnim)
            {
                m_movementAnim.SetBool("IsMoving", true);
            }
        }

        transform.position = Vector3.MoveTowards(transform.position, transform.position + moveVector, Time.deltaTime * currentSpeed);
	
	}