First-Person Shooter Aim Assist by "Snapping" the Crosshair on an Object

Unity Engine
,
1

I have an issue figuring out how to implement an certain method of assisting aim into my game. The goal is to “snap” the crosshair to an enemy if the enemy is close enough to the cursor. A close enough example of what I mean is with GTA’s assisted/auto aim, where if you even somewhat-aim your firearm at someone, the cursor attracts itself exactly to that person. The method that got me the closest to what I wanted was spherecasting, but I am open to other methods and explanations as well. Below is my current method from a firearm script:

Vector3 lookingAt;  

 if (Physics.SphereCast(ray, 0.25f, out RaycastHit hit, accuracyRange, ~LayerMask.GetMask("Boundary"),
     QueryTriggerInteraction.Ignore) && hit.collider.GetComponentInParent<PlayerMovement>() == null)
        //ray is the cursor's screen position raycasted forward into 3d space
{
    Vector3 center = ray.origin + (ray.direction * hit.distance); //acts as cursor but translated hit.distance units forward
    Enemy enemy = (Enemy)hit.collider.GetComponentInParent(typeof(Enemy));

    if (enemy != null)
    {
        player.camera.transform.rotation = Quaternion.Lerp(
            player.camera.transform.rotation,
            Quaternion.LookRotation(enemy.transform.position, center),
            1f * Time.deltaTime
        );
    }
              
    lookingAt = hit.point;
}

This method has a few issues: 1) You can’t really feel like you’re snapping to anything because you have to aim almost exactly at a target for it to even have a chance at working. 2) When I increase the radius to resolve issue 1 so that a target can be hit more easily, I end up with the exact opposite result, meaning that hits seem to be detected less by the SphereCast. 3) The bigger the radius, the more frequent it is for shots to go in completely different and random directions as if they were deflected.

2

I have never made one of these so I figured I’d try my hand at it. This is what I came up with for the actual auto-aiming engine.

The methodology is discussed in the source comments.

In my opinion it has a nice “magnetic” feel to it when the crosshairs go over a visible enemy.

Sorry I don’t have it packaged up in something public but I’ll see if I get some time this weekend to stick it in one of my public projects.

But meanwhile, it’s all laid out for you to enjoy here:

This is the engine script. It has a factory function to help you set it up properly at runtime. It is NOT intended to just be drag-dropped in the editor.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

// @kurtdekker - cheap and cheerful super-generic FPS aim assister

public class AutoAimAssist1 : MonoBehaviour
{
   System.Func<Transform,IEnumerable<Vector3>> GetVisibleTargetLocations;
   IAimAssistable AimAssistable;
   float MaxVectorOffset;

   // Factory method to attach to your stuff. Set this up with:
   //
   //    - the viewpoint you are aiming from (Transform). This script is placed there too.
   //    - your mouse look script, which must implement IAimAssistable interface.
   //    - a function this script can call to say "enumerate me some enemies I can see and possibly target"
   //    - the maximum normalized vector offset (the sine of maximum off-boresight)
   //
   public static AutoAimAssist1 Attach(
       Transform viewpoint,
       System.Func<Transform,IEnumerable<Vector3>> GetVisibleTargetLocations,
       IAimAssistable aimAssistable,
       float maxVectorOffset)
   {
       var aaa = viewpoint.gameObject.AddComponent<AutoAimAssist1>();

       aaa.GetVisibleTargetLocations = GetVisibleTargetLocations;
       aaa.AimAssistable = aimAssistable;
       aaa.MaxVectorOffset = maxVectorOffset;

       return aaa;
   }

   void Update ()
   {
       var TargetLocations = GetVisibleTargetLocations( transform);

       var MyPosition = transform.position;
       var MyForward = transform.forward;

       foreach( var targetLocation in TargetLocations)
       {
           var VectorToEnemy = targetLocation - MyPosition;

           VectorToEnemy.Normalize();

           // essentially the tangent vector between MyForward and the line to the enemy
           var difference = VectorToEnemy - MyForward;

           // how big is that offset along the sphere surface
           float vectorOffset = difference.magnitude;

           // if it is within our auto-aim MaxVectorOffset, we care
           if (vectorOffset < MaxVectorOffset)
           {
               // transform it to local offset X,Y plane
               var localDifference = transform.InverseTransformDirection( difference);

               // normalize it to full deflection
               localDifference /= MaxVectorOffset;

               // scale it according to conical offset from boresight (strongest in middle)
               float conicalStrength = (MaxVectorOffset - vectorOffset) / MaxVectorOffset;
               localDifference *= conicalStrength;

               // send it to the aim assist injection point
               AimAssistable.InjectAutoAim( localDifference);
           }
       }
   }
}

It knows how to call this type of an IAimAssistable object:

using UnityEngine;

// implement this in your main mouse look controller to receive
// steering input from the AutoAimAssist script(s)

public interface IAimAssistable
{
    void InjectAutoAim( Vector2 aim);  
}

In your mouse look script, after all your other calculations are done, you would blend the Vector2 you received via InjectAutoAim() method, something like:

        _mouseAbsolute += LastAimAssist;
        LastAimAssist = Vector2.zero;  // mark it as "processed"

You would choose scaling values to the above vector, since this is extremely dependent on your mouse movement implementation.

The auto-aimer also requires a function like this to retrieve visible enemies. You would provide this in your own enemy manager class:

    IEnumerable<Vector3> GetVisibleTargetLocations( Transform viewpoint)
    {
        foreach( var e in Enemies)
        {
            if (e)
            {
                // TODO: include LOS by considering if viewpoint can even
                // see this enemy, perhaps with raycast or other method.

                yield return e.transform.position;
            }
        }
    }
3

Thanks for the reply, Kurt-Dekker and forgive me for the late response. I’ve taken your most of your code and merged it into my existing code to the best of my ability. There’s just one part of your answer I don’t understand. The variables (or placeholders) “_mousePosition” and “LastAimAssist” in your second-to-last code section is a bit ambiguous, that is, I don’t know what they refer to. Also, is the InjectAutoAim function where the player actually looks at the target?

4

They were the variables in my mouselook code. _mousePosition was the last calculated intended mouse position, and LastAimAssist was a “mailbox” variable (in the mouselook script) where the InjectAutoAim() method (which implements the IAimAssistable interface, which your mouselook must implement) sticks the latest correct.

Think of LastAimAssist as “the nudge that the auto aim wants to give to your cursor this frame.”

The InjectAutoAim() is the one method your mouselook script must implement as part of implementing the IAimAssistable interface, which it also must implement.

Here’s my mouselook script… I got it off the web at the link indicated, but I probably changed it over the years.

See how it implements the IAimAssistable interface by providing the InjectAutioAim() method down at the bottom?

using UnityEngine;

// 5:18 PM 11/15/2017
//
// From: https://discussions.unity.com/t/432898

public class SimpleSmoothMouseLook : MonoBehaviour, IAimAssistable
{
    Vector2 _mouseAbsolute;
    Vector2 _smoothMouse;

    public Vector2 clampInDegrees = new Vector2(360, 180);
    public bool lockCursor;
    public Vector2 sensitivity = new Vector2(2, 2);
    public Vector2 smoothing = new Vector2(3, 3);
    public Vector2 targetDirection;
    public Vector2 targetCharacterDirection;

    // Assign this if there's a parent object controlling motion, such as a Character Controller.
    // Yaw rotation will affect this object instead of the camera if set.
    public GameObject characterBody;

    void Start()
    {
        // Set target direction to the camera's initial orientation.
        targetDirection = transform.localRotation.eulerAngles;

        // Set target direction for the character body to its inital state.
        if (characterBody)
        {
            targetCharacterDirection = characterBody.transform.localRotation.eulerAngles;
        }

        first = true;
    }

    bool first;

    void Update()
    {
        // Ensure the cursor is always locked when set
        if (lockCursor)
        {
            Cursor.lockState = CursorLockMode.Locked;
        }

        // Allow the script to clamp based on a desired target value.
        var targetOrientation = Quaternion.Euler(targetDirection);
        var targetCharacterOrientation = Quaternion.Euler(targetCharacterDirection);

        // Get raw mouse input for a cleaner reading on more sensitive mice.
        var mouseDelta = new Vector2(Input.GetAxisRaw("Mouse X"), Input.GetAxisRaw("Mouse Y"));

        // Scale input against the sensitivity setting and multiply that against the smoothing value.
        mouseDelta = Vector2.Scale(mouseDelta, new Vector2(sensitivity.x * smoothing.x, sensitivity.y * smoothing.y));

        if (first)
        {
            first = false;
            _smoothMouse = mouseDelta;
        }

        // Interpolate mouse movement over time to apply smoothing delta.
        _smoothMouse.x = Mathf.Lerp(_smoothMouse.x, mouseDelta.x, 1f / smoothing.x);
        _smoothMouse.y = Mathf.Lerp(_smoothMouse.y, mouseDelta.y, 1f / smoothing.y);

        // Find the absolute mouse movement value from point zero.
        _mouseAbsolute += _smoothMouse;

        // Clamp and apply the local x value first, so as not to be affected by world transforms.
        if (clampInDegrees.x < 360)
        {
            _mouseAbsolute.x = Mathf.Clamp(_mouseAbsolute.x, -clampInDegrees.x * 0.5f, clampInDegrees.x * 0.5f);
        }

        // Then clamp and apply the global y value.
        if (clampInDegrees.y < 360)
        {
            _mouseAbsolute.y = Mathf.Clamp(_mouseAbsolute.y, -clampInDegrees.y * 0.5f, clampInDegrees.y * 0.5f);
        }


        // 6:41 AM 8/21/2018 - hack in the right joystick sticks
        const string JoystickLookX = "Joy3";
        const string JoystickLookY = "Joy4";
        Vector2 joystickRaw = new Vector2(
            Input.GetAxis( JoystickLookX),
            Input.GetAxis( JoystickLookY)) * Time.deltaTime;
        joystickRaw.x *= 300;
        joystickRaw.y *= 150;

        // invert!
        joystickRaw.y *= -1;

        _mouseAbsolute += joystickRaw;



        _mouseAbsolute += LastAimAssist;
        LastAimAssist = Vector2.zero;



        transform.localRotation = Quaternion.AngleAxis(-_mouseAbsolute.y, targetOrientation * Vector3.right) * targetOrientation;

        // If there's a character body that acts as a parent to the camera
        if (characterBody)
        {
            var yRotation = Quaternion.AngleAxis(_mouseAbsolute.x, Vector3.up);
            characterBody.transform.localRotation = yRotation * targetCharacterOrientation;
        }
        else
        {
            var yRotation = Quaternion.AngleAxis(_mouseAbsolute.x, transform.InverseTransformDirection(Vector3.up));
            transform.localRotation *= yRotation;
        }
    }


// IAimAssistable area:
    Vector2 LastAimAssist;

    const float AutoAimLateralStrength = 1.0f;
    const float AutoAimVerticalStrength = 1.0f;

    public void InjectAutoAim (UnityEngine.Vector2 aim)
    {
        var x = aim.x;
        var y = aim.y;

        x *= AutoAimLateralStrength;
        y *= AutoAimVerticalStrength;

        LastAimAssist = new Vector2( x, y);
    }
}
5

After hours of trial and error, I’ve finally developed a solution of sort in my Firearm script. Check it out:

Enemy targetEnemy; //Stores the current enemy the aim assist script is targeting
MouseLook camera = player.camera.GetComponent<MouseLook>();  //holds a variable of class MouseLook, which handles how the player can look around
Ray ray = player.camera.ScreenPointToRay(player.cursor.position);  //Raycasts from the cursor on the player's camera forward


if (GamePreferences.AimAssist)
{
    foreach (Enemy enemy in GameSingleton.instance.allEnemies)
    {
        if (Vector.Distance(player.transform.position, enemy.transform.position) <= accuracyRange). //Limits the range of enemies to only those who are near enough
        {
            if (Vector3.Angle(camera.transform.forward, enemy.transform.position - player.transform.position) <= 25f) //If the enemy is essentially in front of the player…
            {
                //This is basically the enemy’s position shifted upward so that, in this case, the neck is targeted
                Vector3 enemyPoint = enemy.transform.position + enemy.transform.up * 2.88f;

                /*
                    Gets one point from a set of points equidistant from the player/camera. Because the distance is based on the distance between the player
                    and the enemy, the closer the cursor is to an enemy, the more likely it is for the enemy to be “in range” of the point.
                */
                Vector3 aimAssistPoint = ray.GetPoint(Vector3.Distance(enemyPoint, camera.transform.position));

                //If the enemy is within 1.5 units from the point the player is looking at. In other words, if the cursor is close enough to the enemy…
                if (Vector3.Distance(aimAssistPoint, enemyPoint) <= 1.5f).
                {
                    if (targetEnemy == null)
                    {
                        //Fix cursor on enemy for one second
                        StartCoroutine(ToggleMouseLook(1f, camera, enemy);  //See: ToggleMouseLook
                        camera.transform.LookAt(enemyPoint);
                    }
                }
            }
            else
            {
                //Once the player looks away from the target enemy or the target enemy is dead, reset the targetEnemy var to null so that an enemy can be targeted again
                if (enemy == targetEnemy || (targetEnemy && targetEnemy.IsDead())
                {
                    targetEnemy = null;
                }
            }
        }
    }
}

And the ToggleMouseLook coroutine that actually restricts the cursor to an enemy…

IEnumerator ToggleMouseLook (float delay, MouseLook mouseLook, Enemy enemy)
{
    //Disables the player’s ability to look for delay seconds so that the targeting is not disrupted
    mouseLook.enabled = false;
    yield return new WaitForSeconds(delay);
    mouseLook.enable = true;

    targetEnemy = enemy;  //Assigns the enemy passed in to the targetEnemy var to end targeting

}

It’s not perfect because there are still some inconsistencies I need to correct, but it good enough. If you’d like: you can test this script out for yourself and reply to me with the solution improved.

1 Like