Forem: Sivakumar Prasanth

Sliding Window: Intermediate

Sivakumar Prasanth — Sun, 01 Mar 2026 15:51:36 +0000

Welcome to my algorithmic journey!

If you've ever looked at a coding challenge and felt like you were staring at a brick wall, you aren't alone. Most of the time, the secret isn't about being a math genius, it's about recognising the pattern.

In this series, we are breaking down the most essential coding patterns from beginner to expert level, keeping things simple, practical, and (hopefully) a little bit fun.

Today, we are diving deep into Sliding Window Technique. Whether you are preparing for a big interview or just trying to write cleaner, faster code, mastering this pattern is a total game-changer.

Let's strip away the jargon and see how it actually works!

What is Sliding Window?

Imagine you have a long, delicious Subway sandwich (our array), and you're trying to find the 3-inch section with the most olives. Instead of cutting a 3-inch piece, measuring the olives, throwing it away, and then cutting another 3-inch piece from scratch, you simply slide a 3-inch magnifying glass along the sandwich. As the glass moves:

It welcomes a new olive on the right.
It says goodbye to an old olive on the left.

In the world of coding, a Sliding Window is a technique used to perform operations on a specific "subset" of data (like a subarray or a substring) without re-calculating everything from zero.

The Mathematical Logic

In a standard "Brute Force" approach, if you want to find the sum of every 3-item window in an array, you'd do this:

Sum items 1, 2, and 3.
Forget everything.
Sum items 2, 3, and 4.
Forget everything.
Sum items 3, 4, and 5…

That is a lot of wasted energy! The Sliding Window logic says: "Hey, items 2 and 3 were in both windows. Why calculate them again?"

The "Add & Subtract" Trick

Mathematically, the logic is as simple as a revolving door at a mall.

The Entry: A new element joins the window from the right (+).
The Exit: The oldest element leaves the window from the left (-).
The Middle: Everything else stays exactly where it is!

If we are looking for the sum of a window (W), and we move from position i to i+1:

NewSum = OldSum - ElementAt(i) + ElementAt(i + WindowSize)

Efficiency and Complexity

Before we break down the performance of this algorithm, it's important to understand how we measure "speed" and "memory" in the coding world. We use something called Big-O Notation. If you aren't familiar with terms like O(n) or O(1), or if you just need a quick refresher so you don't get lost in the numbers, check out my previous guide here.

How it solves Time Complexity
In a typical "Brute Force" approach (the loop-inside-a-loop nightmare), the time complexity is usually O(N x K), where N is the total number of items and K is the size of your window. If both are large, your program slows down to a crawl. With the Sliding Window, we achieve the holy grail of performance: O(N).

How it solves Space Complexity
Most Sliding Window problems have a Space Complexity of O(1) (Constant Space).

Why? Because you aren't creating a new array for every window. You are just keeping track of a few variables (like current_sum, max_length, or two pointers called left and right).
The Exception: If you're using a Hash Map or a Frequency Table to keep track of characters (like in the "Longest Substring with Unique Characters" problem), your space might grow to O(K), where K is the size of your character set. But even then, it's usually much smaller than the original data!

Where is it used? (Applications)

Video Streaming (The "Buffer" Window): Ever notice how YouTube or Netflix loads a little bit of the video ahead of where you are? That's a sliding window! The Window: The 30 seconds of video currently being downloaded. The Slide: As you watch one second, the window "slides" forward to download the next second. It keeps a constant "window" of data ready so your movie doesn't lag.

Network Congestion (TCP/IP): The internet is basically a giant series of tubes. If a computer sends too much data at once, the tubes clog. To fix this, the internet uses a "Sliding Window Protocol." It sends a specific number of packets (the window). It only "slides" to send the next packet once the receiver says, "Got it!" This prevents your Wi-Fi from having a total meltdown.

Health & Fitness Tracking: If your Fitbit or Apple Watch tells you your "Moving Average Heart Rate," it's using this technique. Instead of showing your heart rate from 3 hours ago, it calculates the average of just the last 5 minutes. Every minute that passes, it drops the oldest minute and adds the newest one. This gives you a smooth, real-time update.

Classic Interview Problems

You are given an array and asked to find the highest total you can get by adding up exactly K numbers in a row. This is the "Hello World" of the Fixed Sliding Window.

You are given a string and asked to find the longest part of it that contains only a specific number of unique letters. This is the "Accordion" of Sliding Window, where your window grows and shrinks based on what it finds.

You are given two strings and asked to find the shortest possible "slice" of the first string that has every letter of the second string inside it. This is the "Final Boss" that teaches you how to perfectly balance expanding and contracting your window.

Implementation

Now, let's see this pattern in action!

For these demonstrations, I'll be using C#. However, don't let the language choice stop you if you usually code in Python, Java, JavaScript etc. The logic and the underlying pattern remain exactly the same across all languages, only the syntax changes. Feel free to follow along and implement the logic in your own preferred language.

Fixed Size Sliding Window:
The general steps to solve these questions by following below steps:

Find the size of the window required, say K.
Compute the result for 1st window, i.e. include the first K elements of the data structure.
Then use a loop to slide the window by 1 and keep computing the result window by window.

Ex: You are given an array representing the hourly electricity usage (in kilowatts) of a small neighborhood over a 24-hour period. Find the maximum total energy consumed during any continuous 3-hour "Peak Period.

public class HelloWorld
{
    private static int GetMaxTotalEnergy(int[] array, int subArraySize){
        // Invalid
        if(array.Length < subArraySize) return -1;

        int currentSum = 0;

        // First window sum
        for(int i = 0; i < subArraySize; i++){
            currentSum += array[i];
        }

        int maxSum = currentSum;

        int arrayLength = array.Length - subArraySize + 1;

        for(int i = 1; i < arrayLength; i++){
            currentSum += array[i + subArraySize - 1] - array[i - 1];

            maxSum = Math.Max(maxSum, currentSum);
        }

        return maxSum;
    }

    public static void Main(string[] args)
    {
        int[] myArray = {4, 2, 10, 8, 7, 6, 3, 2, 1, 5};
        int k = 3;

        Console.WriteLine("Maximum total energy of a subarray of size " + k + " is: " + GetMaxTotalEnergy(myArray, k));
    }
}

Variable Size Sliding Window:

The general steps to solve these questions by following below steps:

We increase our right pointer one by one till our condition is true.
At any step if our condition does not match, we shrink the size of our window by increasing left pointer.
Again, when our condition satisfies, we start increasing the right pointer and follow step 1.
We follow these steps until we reach to the end of the array.

Ex: Given an array of positive integers and a target sum, find the length of the smallest contiguous subarray whose sum is greater than or equal to that target. If no such subarray exists, return 0.

public class HelloWorld
{
    private static int GetSmallestSubarray(int[] array, int target) 
    {
        int left = 0;
        int currentSum = 0;
        int minLength = int.MaxValue;

        for (int right = 0; right < array.Length; right++) 
        {
            currentSum += array[right];

            while (currentSum >= target) 
            {
                int currentWindowSize = right - left + 1;
                minLength = Math.Min(minLength, currentWindowSize);

                currentSum -= array[left];
                left++; 
            }
        }

        return minLength == int.MaxValue ? 0 : minLength;
    }

    public static void Main(string[] args) 
    {
        int[] numbers = { 1, 2, 3, 4, 5 };
        int targetSum = 7;

        Console.WriteLine("Smallest subarray length: " + GetSmallestSubarray(numbers, targetSum));
    }
}

Practice Roadmap

Theory is great, but coding is a sport. You only get better by practicing! To help you master this pattern, I've curated a list of LeetCode problems. To get the most out of your study time, I recommend following the 3:6:1 ratio (or the 3:5:2 if you're feeling brave!):

30% Easy to build your confidence and grasp the core logic.
https://leetcode.com/problems/maximum-average-subarray-i
https://leetcode.com/problems/substrings-of-size-three-with-distinct-characters/
https://leetcode.com/problems/contains-duplicate-ii/

60% Medium to learn how to apply the pattern in tricky scenarios.
https://leetcode.com/problems/longest-substring-without-repeating-characters
https://leetcode.com/problems/max-consecutive-ones-iii
https://leetcode.com/problems/minimum-size-subarray-sum
https://leetcode.com/problems/find-all-anagrams-in-a-string
https://leetcode.com/problems/fruit-into-baskets/

10% Hard to challenge your limits and see the pattern at its peak.
https://leetcode.com/problems/minimum-window-substring/
https://leetcode.com/problems/sliding-window-maximum/

Don't get discouraged if you get stuck! The goal isn't to solve it in five minutes; the goal is to recognise the pattern. Happy coding!

Stay updated with the latest insights and tutorials by following me on Medium, dev.io and LinkedIn. For any inquiries for games or questions, feel free to reach out to me via email. I'm here to assist you with any queries you may have!

Don't miss out on future articles and tips!

Prefix Sum: Beginner

Sivakumar Prasanth — Wed, 25 Feb 2026 02:18:28 +0000

Welcome to my algorithmic journey! If you’ve ever looked at a coding challenge and felt like you were staring at a brick wall, you aren’t alone. Most of the time, the secret isn’t about being a math genius, it’s about recognising the pattern.

In this series, we are breaking down the most essential coding patterns from beginner to expert level, keeping things simple, practical, and (hopefully) a little bit fun.

Today, we are diving deep into Prefix Sum.

Whether you are preparing for a big interview or just trying to write cleaner, faster code, mastering this pattern is a total game-changer.

Let’s strip away the jargon and see how it actually works!

What is Prefix Sum?

Imagine you are standing at the start of a long road, and every mile there is a sign telling you how many coins are buried under the ground at that specific spot. If I asked you, “How many coins are there between mile 3 and mile 8?”, you would normally have to walk from 3 to 8 and add them up one by one.

That works for a short walk, but what if the road is 10,000 miles long and I ask you 1,000 different questions? You’d be exhausted!

Prefix Sum is a preprocessing technique used to create a “running total” of an array. By doing a little bit of work upfront to sum up the elements as you go, you can answer any “range sum” query, asking for the total between any two points in constant time. It turns a repetitive addition task into a simple subtraction task.

The Mathematical Logic

The math behind a Prefix Sum is beautifully simple. We create a new array, let’s call it newArray, where each element at index i stores the sum of all elements from the start of the original array prevArray up to that index.

The Formula:

newArray[i] = prevArray[0] + prevArray[1] + ... + prevArray[i]

Or, more efficiently:

newArray[i] = newArray[i-1] + prevArray[i]

A Simple Example:

Let’s say we have an array of numbers: A = [3, 1, 4, 1, 5]

To build the Prefix Sum array (P), we add as we go:

Index 0: 3
Index 1: 3 + 1 = 4
Index 2: 4 + 4 = 8
Index 3: 8 + 1 = 9
Index 4: 9 + 5 = 14

Prefix Sum Array (P): [3, 4, 8, 9, 14]

Now, if you want the sum of elements from index 2 to 4 (which are 4, 1, 5), instead of adding them, you just take the total at index 4 and subtract the total before index 2:
Result: 14–4 = 10

This works because:

P[4] = A0 + A1 + A2 + A3 + A4
P[2 — 1] = A0 + A1

So,
P[4] — P[2 — 1]= A2 + A3 + A4

Efficiency and Complexity

Before we break down the performance of this algorithm, it’s important to understand how we measure “speed” and “memory” in the coding world. We use something called Big-O Notation. If you aren’t familiar with terms like O(n) or O(1), or if you just need a quick refresher so you don’t get lost in the numbers, check out my previous guide here.

How it solves Time Complexity
Without Prefix Sum, if you want to find the sum of a range in an array of size N, you have to loop through it, which takes O(N) time. If you have M queries, your total time is O(M x N). That’s slow! With Prefix Sum, we spend O(N) time once to build the sum array. After that, every single query is answered instantly in O(1) (constant time) because it’s just a simple subtraction.

How it solves Space Complexity
The trade-off for all that speed is memory. We usually create a new array of the same size as the original to store our running totals. Therefore, Space Complexity: O(N) However, in some cases, if you don’t need to keep the original numbers, you can overwrite the original array to achieve O(1) extra space!

Where is it used? (Applications)

Financial & Sales Analytics: Imagine a dashboard showing total revenue over any custom date range. The system can now calculate the total for a week, month, or quarter instantly, regardless of how many years of data you have.

Image Processing: In computer vision (like the filters on your phone), a 2D version of Prefix Sum called a Summed-Area Table is used to quickly blur images or detect features. It allows the computer to calculate the average color of any rectangular group of pixels in constant time.

Web Analytics: Tracking cumulative website visitors or “active users” over time series data.

Database Query Optimization: Databases use it to speed up “range scans” or “aggregate queries.” When you run a query asking for data between two timestamps, the database might use prefix-style pre-computations to give you the answer faster.

Game Development: Calculating cumulative scores, resources gained over a level, or even managing lighting and shadows in 2D space.

Classic Interview Problems

If you are heading into a coding interview, there are a few “Famous” problems that almost always use Prefix Sum. Recognizing these early will save you a ton of time and stress!

You are given an array and asked to find the sum of elements between two indices multiple times. This is the “Hello World” of Prefix Sum.

You need to find an index where the sum of numbers to the left equals the sum of numbers to the right.

Subarray Sum Equals K: A classic “Level Up” problem. It combines Prefix Sum with a HashMap to find the number of subarrays that add up to a specific value K.

A very beginner-friendly problem where you track net gain/loss at each step essentially building a Prefix Sum array as you “climb.”

Implementation

Now, let’s see this pattern in action!

For these demonstrations, I’ll be using C#. However, don’t let the language choice stop you if you usually code in Python, Java, JavaScript etc. The logic and the underlying pattern remain exactly the same across all languages, only the syntax changes. Feel free to follow along and implement the logic in your own preferred language.

using System;

public class PrefixSumExample
{
    public static void Main()
    {
        int[] nums = { 3, 1, 4, 1, 5 };

        // Preprocessing: Build the Prefix Sum Array
        int[] prefixSum = BuildPrefixSum(nums);

        // Querying: Get sum of range [index 1 to 3] (values: 1, 4, 1)
        // Expected: 6
        int result = GetRangeSum(prefixSum, 1, 3);

        Console.WriteLine("\nSum of range [1 to 3]: " + result);
    }

    public static int[] BuildPrefixSum(int[] A)
    {
        int n = A.Length;
        int[] P = new int[n];

        // The first element is always the same
        P[0] = A[0]; 

        for (int i = 1; i < n; i++)
        {
            // Current Total = Previous Total + Current Element
            P[i] = P[i - 1] + A[i];
        }

        return P;
    }

    public static int GetRangeSum(int[] P, int left, int right)
    {
        // Sum(left, right) = P[right] - P[left - 1]
        if (left == 0) return P[right];

        return P[right] - P[left - 1];
    }
}

Practice Roadmap

Theory is great, but coding is a sport. You only get better by practicing! To help you master this pattern, I’ve curated a list of LeetCode problems. To get the most out of your study time, I recommend following the 3:6:1 ratio (or the 3:5:2 if you’re feeling brave!):

30% Easy to build your confidence and grasp the core logic.

https://leetcode.com/problems/running-sum-of-1d-array/

https://leetcode.com/problems/find-pivot-index/description/

https://leetcode.com/problems/find-the-highest-altitude/

50% Medium to learn how to apply the pattern in tricky scenarios.

https://leetcode.com/problems/subarray-sum-equals-k/description/

https://leetcode.com/problems/product-of-array-except-self/description/

https://leetcode.com/problems/range-sum-query-2d-immutable/

https://leetcode.com/problems/minimum-size-subarray-sum/

https://leetcode.com/problems/contiguous-array/

20% Hard to challenge your limits and see the pattern at its peak.

https://leetcode.com/problems/max-sum-of-rectangle-no-larger-than-k/

https://leetcode.com/problems/trapping-rain-water/description/

Don’t get discouraged if you get stuck! The goal isn’t to solve it in five minutes; the goal is to recognise the pattern. Happy coding!

Stay updated with the latest insights and tutorials by following me on Medium, dev.io and LinkedIn. For any inquiries for games or questions, feel free to reach out to me via email. I’m here to assist you with any queries you may have!

Don’t miss out on future articles and development tips!

How Algorithms Scale with Input Size: Breaking Down Big-O

Sivakumar Prasanth — Mon, 23 Feb 2026 02:16:15 +0000

When it comes to writing efficient code, understanding how your algorithms perform as the input size grows is crucial. This is where time complexity and Big-O notation come in.

In this blog, we’ll break down the most common time complexities from constant time to factorial time and explain why they matter for every programmer aiming to write fast, efficient code.

What is “O” in Big-O notation?

The “O” stands for “Order of”, as in the order of growth of an algorithm. It’s part of Big-O notation, which is used to describe the upper bound (worst-case) growth rate of an algorithm’s time or space requirements as input size increases.

Computing the time complexity of code involves analyzing how the running time grows with the input size (typically denoted as n).

Here’s a structured way to approach it:

Step 01:

Identify the input Figure out what constitutes the input and denote the size of the input with a variable, commonly n.

function sumArray(arr) {
    let sum = 0;
    for (let i = 0; i < arr.length; i++) {
        sum += arr[i];
    }
}

Here, n = arr.length

Step 02:

Count the operations inside loops Focus on the most repeated operations:

Simple for loop:

for (let i = 0; i < n; i++) { ... }

→ O(n)

Nested loops:

for (let i = 0; i < n; i++) {
  for (let j = 0; j < n; j++) { ... }
}

→ O(n²)

Loop with input halving:

while (low <= high) {
    mid = (low + high) / 2;
    ...
}

→ O(log n)

Recursive calls:

function factorial(n) {
  if (n === 0) return 1;
  return n * factorial(n - 1);
}

→ O(n log n)

Step 03: Ignore constants and lower-order terms

If something is O(3n + 10) → it’s O(n)
If it’s O(n² + n) → it’s O(n²)

Here’s the Big-O time complexities ordered from fastest to slowest (i.e., least to most complex) as input size n increases:

1️⃣ O(1) → Constant time Fastest and doesn’t depend on input size
2️⃣ O(log n) → Logarithmic time Very efficient
3️⃣ O(n) → Linear time Grows directly with input size
4️⃣ O(n log n) → Linearithmic time Slightly slower than linear
5️⃣ O(n²) → Quadratic time Slows down fast
6️⃣ O(n³) → Cubic time Very slow
7️⃣ O(2ⁿ) → Exponential time Grows extremely fast so not practical for large n
8️⃣ O(n!) → Factorial time Worst and blows up even for small n 📌

Final Ordered List: O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(n³) < O(2ⁿ) < O(n!)

Understanding time complexity is essential for writing efficient and scalable code. By using Big-O notation, we can analyze how an algorithm’s performance changes with input size, allowing us to make informed decisions about which approach to use.

As you continue to code, keep these time complexities in mind; they’re not just theoretical as well practical tools for better problem-solving.

Stay updated with the latest insights and tutorials by following me on Medium, dev.io and LinkedIn. For any inquiries for games or questions, feel free to reach out to me via email. I’m here to assist you with any queries you may have!

Don’t miss out on future articles and development tips!

Beyond the Script: A Masterclass in Video Game Subtitling

Sivakumar Prasanth — Sun, 22 Feb 2026 02:48:18 +0000

Let’s be honest: we’ve all been there. You’re playing an epic RPG, a character is whispering a dark, ancient secret, and the subtitles are either microscopic, blending into the snow, or flying past at the speed of light.

Subtitles aren’t just a “nice-to-have” anymore.

Roughly 60% of gamers use them,

whether they have hearing disabilities, noisy roommates, or just want to make sure they didn’t miss that one weird elven pun. Based on the legendary GDC talk by Ian Hamilton (and some 80.lv wisdom), here are the golden rules to making your subtitles actually… well, readable.

Size Matters (Don’t Deny It)

Tiny text is the enemy of joy.

The Golden Number: Aim for at least 46px at 1080p.

The Battle of Contrast

If your text is white and your game is set in a blizzard, your players are going to have a bad time.

Don’t just rely on shadows or outlines (those can be hard for players with dyslexia). Use a background box (letterboxing) behind the text. Bonus points if you let players adjust the opacity of that box!

⚠️ The Contrast Cheat Sheet: > To keep things accessible, aim for a contrast ratio of:

4.5:1 for small text.
3:1 for large text.

Not sure if your colours work? Use these handy tools to check:

Keep it Simple, Keep it Clean

Font Choice: Use a clear Sans-Serif font.
Case Sensitive: Avoid ALL CAPS. It feels like the game is screaming at the player.

Don’t Write a Novel

The 2-Line Rule: Stick to a maximum of 2 lines (3 in extreme emergencies).
Character Count: Keep it under 38 characters per line. If the text covers half the screen, you’re making a visual novel, not a subtitle.

Who is Even Talking?

If there are three NPCs on screen and a disembodied voice from a radio, the player needs to know who said what.

Label it: Use speaker names (e.g., Geralt: “Hmm.”) or unique colours for different characters.

Location, Location, Location

Keep your subtitles bottom — center. It’s where the human eye expects them to be. Putting them in random corners of the screen is a great way to give your players a neck ache.

Accuracy (No “Close Enough”)

Voice actors love to ad-lib. That’s great for the performance, but terrible for subtitles. If the actor says “Yeah, let’s go,” but the text says “Yes, we shall depart,” it creates a weird cognitive itch for the player. Double-check your script against the final audio!

Subtitle Everything (The “Default” Rule)

Don’t wait until the gameplay starts to offer subtitles.

Opening Cinematic: Ensure they have text!
The Pro Move: Have subtitles ON by default or ask the player their preference in the very first “Initial Setup” screen before the game even begins.

Captions vs. Subtitles

Subtitles are for speech. Captions are for sounds.

If a creeper is hissing behind the player, or a door is creaking to the left, add a caption: [Eerie creaking from the left]. This is a literal game-changer for accessibility.

Give Them Time to Breathe

Don’t flash text on the screen for half a second. Use timings that allow for a natural reading pace. If the character talks like a machine gun, you might need to edit the text slightly for brevity , but try to keep the soul of the dialogue intact.

The Magic Numbers:

The Minimum Stay: No subtitle should be on screen for less than 1.5 to 2 seconds, even if the character just says “Hi.” Anything shorter is just a blink.
The Reading Speed: Aim for a pace of about 15 to 20 characters per second.
The “Linger” Factor: Leave the subtitle on screen for about 0.3 to 0.5 seconds after the audio ends. This gives the brain a tiny moment to finish processing the sentence before it disappears.
The Gap: Leave at least 2 frames (about 0.1 seconds) of “blank space” between two different subtitles. If one replaces the other instantly, the eye might not even realise the text changed!

The Ultimate Secret: Options!
If there is one takeaway, it’s this: Customization is King. The more toggles you give the player; size, background, speaker names, colors, the more “awards” your game wins in the hearts of players.

Stay updated with the latest insights and tutorials by following me on Medium, dev.io and LinkedIn. For any inquiries for games or questions, feel free to reach out to me via email. I’m here to assist you with any queries you may have!

Don’t miss out on future articles and development tips!

From Brainstorm to Build: Why Every Indie Game Needs a Game Design Document (GDD)

Sivakumar Prasanth — Sat, 21 Feb 2026 08:41:19 +0000

We’ve all been there. It’s 2 AM, you’re staring at the ceiling, and suddenly BAMMM…. The greatest game idea in history hits you. You’re going to make a game. It’s going to be glorious.

But then you wake up the next morning, open your game engine, and… uh… what now?

This is where the Game Design Document (GDD) saves your life.

What is a GDD?

Think of a GDD as the “North Star” for your project. It’s a living document that outlines everything your game is, what it does, and how it’s supposed to feel.

It’s not meant to be a 500-page boring manual (unless you’re making the next GTA game). For us mere mortals, it’s a simple roadmap that keeps us from getting lost in “feature creep” hell.

Why GDD?

Brain Dump: It gets the ideas out of your head and onto paper so you don’t forget that “extra spicy” mechanic you thought of.

Focus: It defines your “Minimum Viable Product” (MVP). It helps you decide what is actually necessary for the game to be fun.

Organization: It helps you set milestones. Instead of “making a game,” you’re just “finishing Milestone #1”.

How to Create One (Using My “Cow Abduction” Game as an Example)

In this game, you take control of a UFO using a top-down perspective. The primary goal of the game is to fly through the area and pick up as many cows as possible to increase your score. However, the mission isn’t just a simple stroll through the pasture; you must skill-fully navigate the screen to avoid projectiles fired by helicopters. As the game progresses, the gameplay mechanics will become more challenging, making the survival of your alien pilot much more difficult.

Let’s break down how to actually fill one out using a simple template.

The Timeline (Don’t skip this!)

Don’t just code aimlessly. Set milestones:

Don’t Let it Sit in Your Brain!

The biggest mistake is thinking you’ll “just remember it.” Write it down. Sketch it out. Even if it’s just a backlog of features you want to add later (like laser-eyes for the cows), put them in the backlog section so they don’t distract you now.

Grab My Template!

To help you get started, I’ve put together a GDD Template based on the one I used for my UFO game. It’s simple, clean, and won’t give you a headache.

Happy developing! Now go and kidnap some cows!

Stay updated with the latest insights and tutorials by following me on Medium, dev.io and LinkedIn. For any inquiries for games or questions, feel free to reach out to me via email. I’m here to assist you with any queries you may have!

Don’t miss out on future articles and development tips!

Mastering State Machines in Unity: A Comprehensive Guide

Sivakumar Prasanth — Tue, 17 Feb 2026 04:26:36 +0000

Welcome to the world of Unity game development! In this article, we’ll delve deep into the concept of state machines and how they can revolutionise the way you manage game logic in your Unity projects. If you’re new to state machines or seeking to enhance your understanding, you’re in the right place. By the end of this read, you’ll have a solid grasp of state machines and how to implement them effectively in your game development endeavours.

You can find my Github repository here.

Let’s dive in!

What is a State Machine?

A state machine is a fundamental concept in computer science and game development that models the behaviour of an entity by defining a finite set of states and transitions between them. Each state represents a specific behaviour or set of actions, and transitions dictate how and when the entity transitions between these states based on certain conditions or events.

Why Do We Need State Machines in Game Development?

State machines offer a structured and modular approach to managing complex behaviours in games. By organising code into discrete states, developers can improve readability, maintainability, and scalability. Additionally, state machines facilitate the implementation of sophisticated AI, player controls, animation systems, and more, leading to more robust and flexible game architectures.

Demo of My State Machine to Control Player States

In this section, we’ll walk through a practical example of implementing a state machine to control player states in Unity. We’ll cover concepts such as player idle, walking, running, attacking and death, demonstrating how to structure the code using state-based logic. By the end, you’ll have a fully functional player controller powered by a state machine, ready to integrate into your own projects.

Step 01

Create a BaseState abstract class. You can define common state behaviours, such as Enter, Update, and Exit methods, ensuring consistency and coherence across your state machine architecture.

Step 02

Now I created an ITriggerState interface to manage triggers within our state machine architecture.

Feel free to divide the interfaces according to your needs.

Step 03

This script is significant. The StateMachine class manages the entering, updating, and switching of states among objects. Since this class is generic, we can now utilise it for various objects such as players, enemies, etc.

Step 04

Here, I’ve created a class called PlayerIdleState to manage the player’s idle state. This class encompasses all the necessary logic for the player while in the idle state. Similarly, you can create separate classes like this. For the demonstration purposes, I’ve created PlayerWalkState, PlayerRunState, PlayerAttackState, and PlayerDeathState.

Since the aforementioned state classes extend the BaseState class, we can create separate classes for different objects with different states.

Step 05

Next, I implemented the PlayerStateMachine class to utilize the StateMachine abstract class. This PlayerStateMachine will incorporate all the states of my player and facilitate the switching of our player’s states.

Step 06

Finally I have my PlayerManager script :)

Conclusion

State machines are a powerful tool in the Unity developer’s arsenal, offering a structured approach to managing complex behaviours and interactions. By understanding the principles behind state machines and practicing their implementation, you’ll be equipped to tackle a wide range of game development challenges with confidence and efficiency. Remember to explore the accompanying sample code on GitHub to reinforce your learning and unleash your creativity in your Unity projects.

Stay updated with the latest insights and tutorials by following me on Medium, dev.io and LinkedIn. For any inquiries for games or questions, feel free to reach out to me via email. I’m here to assist you with any queries you may have!

Don’t miss out on future articles and development tips!

Cinemachine in Unity: Elevate Your Game’s Camera System Like a Pro

Sivakumar Prasanth — Mon, 16 Feb 2026 07:43:04 +0000

Cinemachine is a powerful camera system in Unity that automates and enhances camera control, making it easier to create dynamic and professional-quality camera movements without writing complex scripts.

Why We Need Cinemachine?

🔹 Eliminates Manual Camera Scripting — No need to write custom code for tracking, transitions, or shakes.
🔹 Smart Camera Behaviour — Auto-adjusts based on object movement, avoiding obstacles and maintaining smooth shots.
🔹 Blending & Transitions — Seamlessly switch between different cameras with cinematic effects.
🔹 Advanced Tracking — Lock onto targets, follow players smoothly, and dynamically frame shots.
🔹 Supports Different Genres — Works for FPS, third-person, top-down, racing, platformers, and cutscenes.

Cinemachine Camera Types in Unity

1. Cinemachine Virtual Camera

Most commonly used camera that allows following and looking at a target.
Key Features: Follows a target, allows for damping and noise adjustments.

2. Cinemachine FreeLook Camera

Allows free rotation around a target, great for third-person games.
Key Features: Smooth transition between top, middle, and bottom rigs for varying zoom.

3. Cinemachine 2D Camera

Specifically designed for 2D games.
Key Features: Works with orthographic projection, follows targets smoothly, and is designed to handle 2D-style cameras.

4. Cinemachine Mixing Camera

Blends multiple cameras simultaneously. Instead of a predefined sequence, you can dynamically mix between multiple Cameras.
Key Features: Instead of switching between cameras, the Mixing Camera blends them together based on weights (0 to 1). Allows seamless interpolation between different views.

5. Cinemachine Dolly Camera (With Track)

Moves along a dolly track, creating on-rails movements.
Key Features: Follows a path defined by a Spline or track, useful for cutscenes or guided movement.

6. Cinemachine Dolly Track with Cart

A track-based camera system that uses a cart to follow the track.
Key Features: The cart moves along the dolly track, typically used for cinematic sequences or scripted events.

7. Cinemachine State-Driven Camera

Automatically switches between cameras based on animation states or game conditions.
Key Features: Linked to the Animator to control camera switching.

8. Cinemachine ClearShot Camera

Chooses the best camera angle automatically from a set of cameras, great for dynamic cutscenes.
Key Features: Automatically selects the best camera from a list of candidate cameras based on visibility.

9. Cinemachine Blend List Camera

Blends between multiple virtual cameras based on a list, one after another in a predefined sequence order.
Key Features: Allows smooth transitions between cameras in a sequence, ideal for cutscenes or complex transitions.

10. Cinemachine Target Group Camera

Focuses on a group of targets (like multiple players).
Key Features: Allows dynamic camera movement for multiple targets with adjustable priorities.

Where is Cinemachine Used?

✅ FPS Games — Smooth aim, recoil, and camera shake effects.
✅ Racing Games — Dynamic chase cameras, cockpit views.
✅ Cutscenes & Storytelling — Cinematic transitions, zooms, and pans.
✅ Open-World Games — Automatic tracking of players across large maps.
✅ 2D Platformers — Side-scrolling cameras with precise following.

Is Cinemachine Good For Mobile Games?

Cinemachine can be an excellent choice for mobile games, but like with any tool, it comes with both advantages and considerations.

Advantages of Using Cinemachine in Mobile Games
🔹 Ease of use
🔹 Smooth Camera Movements
🔹 Camera Types and Versatility
🔹 Mobile-Friendly
🔹 Camera Blending and Switching

Considerations When Using Cinemachine in Mobile Games
🔹 While Cinemachine is optimised for performance, it’s still important to monitor and optimise performance, especially on lower-end mobile devices
🔹 Cinemachine cameras can consume more power than simpler, static cameras due to constant updates, camera movement, and smooth transitions

Best Practices for Using Cinemachine in Mobile Games
🔹 Limit Complex Camera Transitions
🔹 Opt for basic smoothing (position and rotation damping) over heavy noise or distortion effects
🔹 Monitor Performance
🔹 Test on Real Devices

Cinemachine simplifies complex camera movements, making your game feel more polished and immersive without heavy coding.

This is a great tool for mobile game development. However, for optimal performance, it’s important to balance the complexity of your camera systems, by following best practices can be effectively used to create high-quality, dynamic camera systems for mobile games.

Whether you’re working on an FPS, RPG, racing, or cinematic cutscenes, Cinemachine helps you achieve professional-quality visuals effortlessly.

Stay updated with the latest insights and tutorials by following me on Medium, dev.io and LinkedIn. For any inquiries for games or questions, feel free to reach out to me via email. I’m here to assist you with any queries you may have!

Don’t miss out on future articles and development tips!

A* Algorithm vs Unity NavMesh: Choosing the Right Pathfinding for Your Game

Sivakumar Prasanth — Sun, 15 Feb 2026 02:27:14 +0000

What’s A*?

A* (A-star) is a search algorithm used to find the shortest path between two points on a grid or graph.

What’s Unity NavMesh?

NavMesh is Unity’s built-in navigation system.

When to Use A* Algorithm

✅ 2D Grid-Based Games: Great for top-down, tile-map games like Pokémon, Fire Emblem
✅ Custom Pathfinding: You need full control over the algorithm or grid
✅ No Unity Engine (Custom Engine): You’re building from scratch
✅ Dynamic or Procedural Worlds: You generate maps at runtime and need custom solutions
✅ Low-poly / Small Worlds: Simple grid = fast A* computation

When NOT to Use A* (Use NavMesh Instead)

🚫 3D Terrain or Complex Geometry: A* doesn’t understand 3D mesh surfaces
🚫 Need Agent Features: No built-in agent radius/height, obstacle avoidance
🚫 Performance Bottlenecks in Large Maps: Grid-based A* gets slow as grid size increases
🚫 Want Auto Pathfinding in Unity: Unity NavMesh does the heavy lifting automatically

When to Use Unity NavMesh

✅ 3D Games (FPS, Adventure): Works out of the box with terrain, stairs, ramps
✅ You’re Using Unity: Built-in, highly optimized, works with Agents and Obstacles
✅ Want Dynamic Pathfinding: NavMesh can update with NavMesh Surface or Carving
✅ Need Agent-Based AI: Handles multiple AI units with different sizes/behavior

When NOT to Use NavMesh (Use A* Instead)

🚫 2D Games: NavMesh is mainly for 3D navigation (2D support is hacky)
🚫 Fully Dynamic Worlds: You can’t rebake NavMesh instantly at runtime
🚫 Custom Game Engines: NavMesh is Unity-specific
🚫 Hex or Irregular Grids: NavMesh doesn’t support custom-shaped tile systems natively

Find my NavMesh Demo Project Here

TL;DR Summary

Top-down 2D tile game: A*
3D Adventure/FPS: NavMesh
Procedural dungeons: A*
RTS / MOBA (3D with units): NavMesh
Custom logic / AI testing: A*
Unity 3D project with terrain: NavMesh

How do I handle dynamic environments in a 3D game where the NavMesh must update instantly at runtime?

Unity’s built-in NavMesh system is not ideal for highly dynamic environments. But there are workarounds & better solutions depending on your game’s needs.

Why NavMesh is Limited in Dynamic Worlds
Unity’s NavMesh baking is not real-time. It takes time and can’t rebake every frame. Even NavMeshObstacle with carving only supports:

Simple object avoidance
No large-scale changes (like terrain deformation or new platforms appearing)

So if your game has:

Platforms moving
Terrain changing
Buildings spawning/despawning

You need more flexible solutions….

Best Solutions for Real-Time Navigation in Dynamic 3D Worlds

✅ Use NavMesh with Carving enabled for minor changes like doors, crates, small obstacles

✅ Use NavMeshComponents package, when only parts of the environment change

✅ A Pathfinding Project (by Aron Granberg)*

Best for fully dynamic 3D worlds
Supports grid, navmesh, and point graph types
Real-time updates & graph recalculations
Unity compatible and production-ready

Why it rocks:

Real-time updates
Supports layered worlds, moving platforms
Optimised & widely used in indie and AAA

Find Aron Granberg’s path finding projects:
Free
Paid

Many devs switch to this when Unity’s NavMesh isn’t enough.

Stay updated with the latest insights and tutorials by following me on Medium, dev.io and LinkedIn. For any inquiries for games or questions, feel free to reach out to me via email. I’m here to assist you with any queries you may have!

Don’t miss out on future articles and development tips!

From Code to Shape: A Beginner’s Guide to Unity Mesh Generation

Sivakumar Prasanth — Sat, 14 Feb 2026 11:16:39 +0000

If you’ve ever wondered how 3D models are built behind the scenes in Unity. While most developers use imported 3D models, Unity also gives you full control to create meshes directly through code. In this blog, we’ll break down the core components of a mesh and walk through how to create a custom mesh using C#.

Whether you’re aiming to generate procedural terrain, dynamic characters, or just want to better understand Unity’s rendering pipeline, this guide will give you the foundation to start crafting geometry with code.

Before we start writing code to generate a mesh, it’s important to understand the key components involved in rendering geometry in Unity.

Mesh

A Mesh is the fundamental building block for rendering 3D models. It is a collection of vertices, triangles, and UVs that together define the shape and surface appearance of a 3D object. Think of it as the skeleton of a model.

Mesh Filter

The Mesh Filter is a component that holds a reference to a mesh. It doesn’t render the mesh or affect how it looks. It simply passes the mesh data to the rendering system. If the mesh is the blueprint, the Mesh Filter is the middleman that hands it to Unity’s renderer.

Mesh Renderer

The Mesh Renderer is responsible for taking the mesh from the Mesh Filter and drawing it on the screen. It handles materials, shaders, and lighting, determining how the mesh will look in the scene. You can think of it as the artist who paints the mesh and makes it visible to the camera.

In Summary

Mesh = The raw data (vertices, triangles, UVs).
Mesh Filter = Holds and passes the mesh to be rendered.
Mesh Renderer = Renders the mesh with materials and lighting.

Now that we understand what a Mesh, Mesh Filter, and Mesh Renderer are, let’s see them in action.

Step 01: Create an Empty GameObject

Step 02: Add Mesh Filter and Mesh Renderer Components

Step 03: Create a New Material

Step 04: Assign a Texture (Optional for Demo)

Step 05: Assign the Material to the Mesh Renderer

Understanding Vertices, UVs, and Triangles

Before we start coding, it’s crucial to understand the three fundamental building blocks of any mesh: vertices, UVs, and triangles.

Vertices

A vertex is a point in 3D space, defined by a coordinate (x, y, z). When you create a mesh, you define its shape by specifying a set of these points. For example, to make a simple triangle, you need three vertices. To create a square (quad), you need four. Think of vertices as the corners or dots that outline your object’s shape.

UVs

UVs are coordinates that map a texture onto your mesh. While vertices define the shape, UVs tell Unity how to paint it. UV coordinates range from (0, 0) to (1, 1), where (0, 0) is the bottom-left of the texture and (1, 1) is the top-right. Each vertex must have a corresponding UV coordinate to ensure the texture is correctly applied.

Triangles

Triangles define how vertices are connected to form surfaces. Every 3D shape in Unity is made up of triangles. Even quads are just two triangles joined together. A triangle is defined by three indices.

The order of these indices matters. It determines which direction the triangle faces (called the winding order). Unity uses a clockwise order to decide the front face of the triangle. Similarly, If needs to show back face, uses counter clock wise.

Time to Code: Creating a Triangle from Scratch

Step 01: Create a new mesh instance

Mesh mesh = new Mesh();

This initializes a new instance of the Mesh class. This will store all the geometry data (vertices, UVs, and triangles) for your custom shape.

Step 02: Assign the mesh to the MeshFilter component on the current GameObject

GetComponent<MeshFilter>().mesh = mesh;

We get the MeshFilter component attached to this GameObject and assign our newly created mesh to it. This tells Unity to use our custom mesh when rendering.

Step 03: Define arrays for vertices, UVs, and triangles with 3 elements (we’re making a single triangle)

Vector3[] vertices = new Vector3[3];
Vector2[] uv = new Vector2[3];
int[] triangles = new int[3];

We declare three arrays to hold the data needed for the mesh

Vertices: the 3D coordinates of each point.
uv: the texture coordinates for each vertex.
triangles: the order in which the vertices are connected to form a triangle.

Step 04: Set the vertex positions (in local space)

vertices[0] = new Vector3(0, 0, 0);     // Bottom-left
vertices[1] = new Vector3(0, 20, 0);    // Top-left
vertices[2] = new Vector3(20, 20, 0);   // Top-right

These are the positions of the three corners of the triangle in 3D space. They define the shape and size of the mesh. This triangle will appear upright and flat on the XY plane.

Step 05: Set UV coordinates corresponding to each vertex

uv[0] = new Vector2(0, 0);  // Bottom-left of the texture
uv[1] = new Vector2(0, 1);  // Top-left of the texture
uv[2] = new Vector2(1, 1);  // Top-right of the texture

These coordinates determine how the texture is mapped onto the triangle. UVs are in 2D (X and Y), ranging from 0 to 1, and are aligned with the texture’s corners.

Step 06: Define the order of vertices to form the triangle

triangles[0] = 0;
triangles[1] = 1;
triangles[2] = 2;

This tells Unity how to connect the vertices to make a triangle. It connects vertex 0 → 1 → 2 in a clockwise order, which defines the front-facing side.

Step 07: Assign the arrays to the mesh

mesh.vertices = vertices;
mesh.uv = uv;
mesh.triangles = triangles;

Finally, we assign our data to the mesh object. Unity now knows what shape to draw (vertices + triangles) and how to map the texture (UVs).

Full Script: Generating a Simple Mesh in Unity via Code

using UnityEngine;

public class MeshGenerator : MonoBehaviour
{
    private Mesh mesh;

    private void Start()
    {
        // Create a new mesh instance
        mesh = new Mesh();

        // Assign the mesh to the Meshfilter
        GetComponent<MeshFilter>().mesh = mesh;

        CreateTriangle();
    }

    private void CreateTriangle()
    {
        // Define arrays for vertices, UVs, and triangles
        Vector3[] vertices = new Vector3[3]; // A triangle has 3 vertex
        Vector2[] uv = new Vector2[3]; // Each vertex should have a currosponding UV coordinate 
        int[] triangles = new int[3]; // A triangle has 3 indices

        // Set the vertex positions (in local space)
        vertices[0] = new Vector3(0, 0, 0);
        vertices[1] = new Vector3(0, 20, 0);
        vertices[2] = new Vector3(20, 20, 0);

        // Set UV coordinates corresponding to each vertex
        uv[0] = new Vector2(0, 0);
        uv[1] = new Vector2(0, 1);
        uv[2] = new Vector2(1, 1);

        // Define the order of vertices to form the triangle
        triangles[0] = 0;
        triangles[1] = 1;
        triangles[2] = 2;

        // Assign the arrays to the mesh
        mesh.vertices = vertices;
        mesh.uv = uv;
        mesh.triangles = triangles;
    }
}

Visual Output: What Our Custom Mesh Looks Like in Unity

Now It’s Your Turn!

Now that you understand the basics of creating a mesh through scripting — using vertices, UVs, and triangles. Go ahead and experiment with differe nt shapes! Try building quads, pentagons, or even more complex forms. Play around with vertex positions, texture mappings, and triangle orders to see how each change affects the result.

Have fun, and don’t be afraid to get creative!

Find My Demo Project Here

Stay updated with the latest insights and tutorials by following me on LinkedIn. For any inquiries for games or questions, feel free to reach out to me via email. I’m here to assist you with any queries you may have!

Don’t miss out on future articles and game development tips!

Unity Physics Body Types

Sivakumar Prasanth — Fri, 13 Feb 2026 10:24:36 +0000

In game development, realism isn’t just about stunning visuals. It’s also about how objects behave in the world. Unity’s physics engine plays a key role in bringing these interactions to life.

Static Bodies

Static bodies are completely immobile. Once placed in the scene, they stay fixed in position and rotation. They don’t respond to forces or collisions. But other objects can collide with them.

Key Characteristics:

No Rigidbody required in 3D (collider alone is enough)
Use Rigidbody2D with bodyType = Static in 2D
Ideal for: walls, floors, terrain, or background structures
Optimised for performance. Unity doesn’t have to recalculate their position

Kinematic Bodies

Kinematic bodies don’t respond to physics forces or collisions themselves, but they can still affect Dynamic bodies if they move into them. They’re moved through scripting (e.g., by changing transform.position or setting velocity).

Key Characteristics:

Set isKinematic = true on Rigidbody (3D)
Set bodyType = Kinematic on Rigidbody2D (2D)
Not affected by gravity or collisions
Useful for: elevators, doors, conveyor belts, or moving platforms

Dynamic Bodies

Dynamic bodies are fully simulated by the physics engine. They respond to gravity, forces, collisions, and other physical interactions. These are the most “alive” objects in your scene.

Key Characteristics:

Requires Rigidbody (3D) or Rigidbody2D (2D)
Use bodyType = Dynamic for 2D
Reacts to AddForce, velocity, mass, and friction
Ideal for: players, enemies, falling crates, or any object that moves physically

Choosing the Right Type

Use Static for anything that never moves
Use Dynamic when you want full physics interaction
Use Kinematic when you need scripted or manual movement without physics influence

Don’t miss out on future articles and game development tips!

Unity for Animators: A Step-by-Step Breakdown of the Film Production Pipeline

Sivakumar Prasanth — Thu, 12 Feb 2026 02:39:15 +0000

In today’s fast-evolving world of digital storytelling, animation is no longer confined to traditional tools and linear pipelines. With the rise of real-time engines, studios are now exploring faster, more flexible, and more collaborative workflows.

Unity, a game engine known for its power in interactive content, has rapidly become a favourite in the animation and film industries, not just for previews, but for full-fledged production. This blog takes you through a step-by-step breakdown of the film production pipeline from storyboarding to final compositing and explores how Unity fits into each stage.

Let’s dive into the pipeline and see how Unity is bridging the gap between creativity and technology like never before.

This pipeline shows the stages from story conception to the final rendered film or animation, where Unity can be used as a real-time engine to accelerate, preview, or replace traditional rendering steps.

Story

The foundation of the animation or film.
Involves scriptwriting, storyboarding, and defining the narrative structure.

Art

Concept art, character design, and environment art are created.
Sets the visual tone and style.

Editorial

Combines storyboards or animatics to build a rough cut or visualisation.
Unity can be used here for real-time pre-visualisation.

Modeling

3D assets (characters, props, environments) are created using tools like Blender, Autodesk Maya, Modo or Cheetah3D.
Assets are exported in any of the Unity support format and can be imported into Unity.

Rigging

Bones and control rigs are added to characters and objects.
These are what animators use to pose or animate characters.

Animation

Characters and objects are animated using keyframe animation or motion capture.
Unity supports importing animated rigs and editing animations via the Animation window or Timeline.

Crowds

Systems for animating large groups (e.g., background characters or armies).
Unity supports crowd simulations using tools or custom AI.

Layout

Sets up camera positions, blocking, and rough animations.
This stage ensures visual storytelling is clear before final polish.
Unity’s Timeline and Cinemachine are powerful tools here.

Surfacing

Applies materials and textures to models.
Unity’s Shader Graph and HDRP offer film-quality surfacing.

Character FX

Includes things like hair dynamics, cloth simulation, muscle jiggle.
Unity supports real-time simulations or baked effects.

FX (Effects)

Visual effects like fire, smoke, magic, water.
In Unity, these can be done using the VFX Graph or Particle System.

Lighting

Establishes mood and visibility using light placement and environment lighting.
Unity supports physically based lighting, global illumination, and real-time rendering.

Matte Painting

2D/3D background art.
Can be projected into Unity scenes for fast environment setup.

Compositing

Combines all renders (characters, FX, backgrounds) into the final image.
In Unity, this can be partly real-time using post-processing effects or done in external software.

How Unity Fits into This Pipeline

Real-time pre-visualisation (Story + Editorial).
Asset ingestion from DCC tools (like Maya/Blender).
Non-linear animation editing with Timeline + Animator.
High-quality visuals using HDRP (High Definition Render Pipeline).
Live rendering for scenes, helping iterate faster than traditional offline renderers.
Rendering final output using Unity Recorder or USD export for compositing.

Key Tools in Unity’s Asset Workflow

FBX/GLTF/OBJ Importers: Bring in 3D models.
Timeline & Cinemachine: Animate and direct scenes.
Animator & Animation Window: Control character animations.
Shader Graph: Create high-end materials. V
FX Graph & Particle System: Build dynamic visual effects.
HDRP: Film-quality lighting and visuals.
Unity Recorder: Capture sequences for compositing or editing.

Summary

Unity supports film and animation pipelines by providing a real-time platform to:

Speed up iteration.
Preview scenes live.
Reduce rendering times.
Integrate assets from traditional tools.

It complements or even replaces parts of traditional pipelines, especially for studios looking to cut down post-production time.

Don’t miss out on future articles and game development tips!

The Great Debate: Rigidbody vs Character Controller for Player Movement in Unity

Sivakumar Prasanth — Wed, 11 Feb 2026 05:12:30 +0000

When it comes to player movement in Unity, one question continues to spark debate among developers: Should I use a Rigidbody or a Character Controller?

In this blog, we’ll dive deep into the differences between Rigidbody and CharacterController components, how they behave, when to use them, and the challenges they present. By the end, you’ll have a clearer picture of which system suits your project best and why this decision can significantly impact your gameplay feel and performance.

Character Controller

The CharacterController is a built-in Unity component designed for player controlled movement without using full physics simulation. It doesn’t use Rigidbody forces, instead, you move it using the Move() or SimpleMove() functions.

Rigidbody (Dynamic)

A Dynamic Rigidbody is a physics driven object. It reacts to forces, collisions, and gravity. This is Unity’s full-fledged physics simulation component.

Rigidbody (Kinematic)

A Kinematic Rigidbody means the object has a Rigidbody component, but physics won’t affect it (e.g., no gravity, no automatic response to collisions). Instead, you control its motion manually.

Key Features

Affected by Gravity / Physics Interactions
❌ Character Controller (Need to handle via script)
✅ Rigidbody - Dynamic
❌ Rigidbody - Kinematic

Collision Detection
✅ Character Controller
✅ Rigidbody - Dynamic
❌ Rigidbody - Kinematic (They can be used to trigger events when they overlap with other colliders)

You must add a Collider manually in Rigidbody but no external collider is required for Character controller hence the Character Controller component includes a built-in Capsule Collider.

Slope Traversal / Stair Handling
✅ Character Controller (Build-in)
❌ Rigidbody — Dynamic (Needs custom logic)
❌ Rigidbody — Kinematic

Best For

Character Controller

FPS or third-person controllers
Smooth, responsive movement
Games where fine-tuned control is more important than realistic physics

Character controller is best for snappy movement (A movement style in games that feels fast, responsive, and immediate, with minimal delay or momentum).

Why Character Controller Wins for Snappy Movement:

Direct, Immediate Movement: You move using Move() or SimpleMove(), which gives instant control with no delay or inertia.
No Physics Overhead: It bypasses Unity’s physics system, so you’re not fighting against forces, drag, or unwanted sliding.
Consistent and Predictable: Your player moves the same way every time, regardless of frame rate, slope, or surface type.
Built-in Slope and Step Handling: It handles climbing small steps and walking up slopes without custom logic.

Why Rigidbody is Trickier for Snappy Movement:

Rigidbody.velocity can work, but it’s sensitive to: Gravity, Friction/drag and Bouncing on collision
Using AddForce() is not snappy. It introduces momentum and delay unless carefully tuned.

Exceptions:
If you need physics interactions (e.g., knockbacks, bouncing, pushing objects), a Rigidbody with velocity control can still work. But requires more effort to feel “snappy.”

Rigidbody - Dynamic

Objects needing realistic physics (e.g., rolling, bouncing, falling)
Platformers, puzzle games, or any physics based gameplay
Multiplayer physics interactions

Dynamic Rigidbody is best for momentum based movement (A movement style in games where characters or objects behave with realistic inertia, meaning their mass, speed, and previous velocity affect how they start, stop, and change direction just like in the real world).

Why Rigidbody Is Best for Momentum-Based Movement:

Real Physics Simulation: Rigidbody is built to simulate real-world motion: acceleration, deceleration, inertia, gravity, and mass all affect how the object moves.
Natural Momentum: Using Rigidbody.AddForce() or AddRelativeForce() allows movement to build up and decay over time, creating realistic sliding, drifting, or weighty motion.
Supports Collisions & Physical Reactions: It interacts properly with other physics objects, bouncing, pushing, and reacting naturally.
Adjustable Through Physics Settings: You can tune mass, drag, and angular drag to get the exact momentum feel you want.

Why Character Controller Doesn’t Fit:

CharacterController uses manual, non-physics-based movement.
It doesn’t simulate momentum. Movement starts and stops immediately.
You’d have to fake momentum yourself using custom variables and logic.

Rigidbody — Kinematic

Moving platforms
Cutscene objects
Controlled AI agents that need to interact with physics objects but aren’t affected by them

When it comes to creating movement that feels natural, weighty, and physically responsive, Rigidbody based movement is the clear choice. Its built-in physics simulation gives you momentum “for free,” enabling acceleration, deceleration, and realistic reactions to forces all essential ingredients for immersive gameplay.

While the Character Controller shines in tight, snappy movement systems, it falls short when momentum and physics-based interactions are critical.

If your game involves sliding, drifting, inertia, or physically-reactive characters, a dynamic Rigidbody setup is your best bet. Ultimately, your choice depends on your game’s feel, style, and player experience goals but for momentum based movement, Rigidbody wins with physics on its side.

👉 Check out the demo project on GitHub
Includes a simple Unity scene showcasing Rigidbody vs Character controller.

Don’t miss out on future articles and game development tips!