DEV Community: Steller

Player Movement (New Input System)

Steller — Mon, 08 Jun 2026 13:18:28 +0000

You got your cube moving around in my last article, but you've heard about Unity's New Input System and you're inexplicably drawn to things that have “new” in the name. In this article, we'll walk through installation of the New Input System, and overhaul our previous movement system using an event driven system. This will also allow us to easily provide support for multiple input types.

Install

Window > Package Manager
Ensure you're looking at “Packages: Unity Registry” and run a search for “Input System”.
Select “Input System” from the list that's returned and use the Install button in the bottom right of the Package Manager window.

Installing this package will disable the original Input Manager.

Setup

Edit > Project Settings > Input System Package
Click “Create settings asset”
You can leave the default settings for now.

Setup InputActions object
If you try to run your game now, you're going to get hit by an error that looks like this:

This is because we disabled the old Input Manager, so we need to take some steps to make use of the newly installed Input System instead.

Click on your “Player” object in the Hierarchy window.
In the Inspector window, Add Component > Player Input.
You'll be prompted to save your new .inputactions file. I've created a folder in Assets called “InputActions” and named the file “Controls”
Double-click the Controls item in your Project window

Because we're focusing on movement, let's delete the “UI” action map, as well as the “Look” and “Fire” actions. Additionally, selecting the “Auto-Save” checkbox can save you a headache in the future.

Click on the Action called “Move” and change the Control Type to “Vector 3”.

Click on your Controls object in the Projects window, turn on “Generate C# Class” and click “Apply”.

Click on your Player object to view it in the Inspector. Drag PlayerActions from your Assets into the “Actions” value in the Player Input component and change the “Behaviour” to “Invoke Unity Events”.

Code Refactor
Go ahead and open up your Player script in your IDE and we'll make a couple changes here.

First, we want to delete the following lines in void Update():

float horizontalInput = Input.GetAxis("Horizontal");
float verticalInput = Input.GetAxis("Vertical");

Next, we'll remake these as a single so that we can feed it values whenever input is triggered.

private Vector3 _direction;

Then we'll make a small revision to the class definition:

public class Player : MonoBehaviour, Controls.IPlayerActions

We add , Controls.IPlayerActions to the class definition so that it can reference the C# class we made out of our Input Action Asset earlier. Depending on your IDE, you may see this throwing an error. “Controls” will be different depending on what you called your Input Actions asset.

Clicking to light bulb here will give you the option to “Implement Missing Members” which will auto-generate a void called OnMove that is triggered whenever one of our defined Actions is triggered by the inputs we're watching for as defined in the Input Actions.

Back to Unity
We'll need to jump back to Unity for a moment now that we've got our void OnMove() defined.

In the Player object, find your Player Input component and expand Events > Player. Hit the “+” in the “Move (CallbackContext)” box. Drag your Player object from the Hierarchy window to the empty Object space and then No Function > Player > OnMove.

Back to Code
Before we move on, it's important to understand that we're no longer actively checking if the player is providing input inside of our void Update()

The new Input System supports event driven interactions so we're only running movement related code when the user is actively attempting to move.

Back in our code we now have our void OnMove() defined and we can start working with it. First up is getting some sort of value we can use back from our context object.

public void OnMove(InputAction.CallbackContext context)
{
    Debug.Log(context.ReadValue<Vector2>());
}

The above is going to fetch us a Vector2 to represent our horizontal and vertical axes. The Debug.Log I'm using would read out in a couple different ways. For instance, if we're pressing the the D key, we'll see (1,0) whereas the S key would read (0,-1)

Now that we know we're getting values back from our inputs, we can start feeding that Vector2 value into our _direction Vector3, like so.

public void OnMove(InputAction.CallbackContext context)
{
    _direction = context.ReadValue<Vector2>();
}

One final step. We're going to revise the code we have in our void Update()

void Update()
{
    transform.Translate(_direction * (_speed * Time.deltaTime));
}

Because we're storing our _direction as a Vector3, we can now control the movement with a single line of code by multiplying (_speed * Time.deltaTime) by our _direction

Hop into Unity and run your game. You should be able to use the WASD keys just like before, but if you hook up a gamepad, XR controller, or a Joystick, you'll be able to use those instead!

The Power of Raycasting in Unity: Tips, Tricks, and Best Practices

Steller — Sun, 07 Jun 2026 19:25:51 +0000

Introduction
Raycasting is one of the most powerful tools in Unity's physics system, and it plays a vital role in both 2D and 3D game development. Whether you're creating shooting mechanics, implementing AI vision, or checking for player interaction, raycasting is a go-to technique for detecting objects and simulating line-of-sight. In this guide, we'll explore the full potential of raycasting in Unity and share tips, tricks, and best practices that will help you implement it effectively in your games.

What is Raycasting in Unity?
Raycasting is the process of sending out an invisible ray from a specific point in a direction and detecting if it hits any collider in the scene. Unity provides:

Physics.Raycast for 3D
Physics2D.Raycast for 2D

Each function returns detailed information about the hit, including the object hit, the point of impact, the surface normal, and more.

When Should You Use Raycasting?
Raycasting can be used in a variety of scenarios:

Shooting mechanics (e.g., bullets or lasers)
Line-of-sight detection for AI
Mouse and touch input interaction
Obstacle detection
Ground checks and wall checks for platformers

Raycasting Basics: Syntax and Usage
Here's a basic 3D raycast example:

Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out RaycastHit hit))
{
    Debug.Log("Hit object: " + hit.collider.name);
}

And for 2D:

RaycastHit2D hit = Physics2D.Raycast(transform.position, Vector2.right);
if (hit.collider != null)
{
    Debug.Log("2D Hit: " + hit.collider.name);
}

Useful Raycasting Tips and Tricks
1. Use Layer Masks for Performance
Avoid unnecessary collision checks by filtering which layers the raycast should interact with:

int layerMask = LayerMask.GetMask("Enemy");
Physics.Raycast(origin, direction, out hit, distance, layerMask);

2. Limit Raycast Distance
Always define a maximum distance to prevent performance issues:

float maxDistance = 100f;
Physics.Raycast(origin, direction, out hit, maxDistance);

3. Visualize Rays with Debug.DrawRay
This helps you understand how your rays are working in the scene:

Debug.DrawRay(origin, direction * maxDistance, Color.red);

4. Raycasting from Camera for UI/3D World Interaction
Perfect for selecting objects or NPCs:

Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);

5. Check for Multiple Hits with RaycastAll
To detect all objects along the ray path:

RaycastHit[] hits = Physics.RaycastAll(ray);
foreach (RaycastHit hit in hits)
{
    Debug.Log("Hit: " + hit.collider.name);
}

Best Practices for Raycasting in Unity
✅ Use non-allocating versions like RaycastNonAlloc() in performance-critical areas
✅ Combine with colliders and Rigidbody for accurate detection
✅ Avoid using raycasts every frame unless absolutely needed (e.g., cache results)
✅ Use fixed update for physics-related raycasting
✅ Separate raycasting logic by layers and object types to keep your code clean

Common Raycasting Mistakes to Avoid
❌ Using Physics.Raycast in a 2D game instead of Physics2D.Raycast
❌ Forgetting to add colliders to target objects
❌ Not handling null references from missed raycasts
❌ Casting rays in the wrong direction (check your vector math!)
❌ Not visualizing rays during development

Real-World Use Cases
FPS games: Detecting bullet hits
Puzzle games: Triggering objects by pointing or clicking
Stealth games: AI vision and alert states
Platformers: Checking for ground/wall presence

Conclusion
Raycasting is an incredibly flexible and efficient technique that can solve many core gameplay challenges in both 2D and 3D games. By following the best practices and using the tips shared in this guide, you can make your game logic smarter, more responsive, and performance-friendly. Whether you're a beginner or an experienced Unity developer, mastering raycasting will empower you to create more interactive and immersive experiences.

Start experimenting today and unlock the true power of Raycasting in Unity!

Also Check : Raycast Unity 2D for Object Detection