Portfolio

Back To Home

Unity

4-04-2024


Say Goodbye to Tedious Loops! LINQ: Your New Unity BFF

Are you tired of writing the same for loop over and over again until your fingers cramp and your soul cries out for mercy?

Fear not, weary warriors of code! Today, we unveil a secret weapon that will banish tedious loops to the dusty corners of your Unity project: LINQ (pronounced "link"). Think of it as your new best friend (BFF) in the data wrangling world – efficient, powerful, and guaranteed to make your coding life a whole lot easier. So, grab your keyboard (and maybe a cup of coffee for all those loops you'll no longer be writing), and let's dive into the wonderful world of LINQ in Unity!

What is LINQ?

LINQ stands for Language Integrated Query. Wow, that sounds fancy, right? But what does it mean? Basically, LINQ helps us ask questions to our computer and get answers in a really cool and efficient way. It’s like having a super-smart assistant who can find things for you quickly!

LINQ Queries:

Imagine you have a bunch of toys, and you want to find all the red ones. Instead of searching through each toy, you can ask LINQ to find all the red toys for you. LINQ will go through your toys and pick out only the red ones, saving you a lot of time and effort!

Key LINQ Operations:

LINQ provides a rich set of operators for filtering, sorting, transforming, and aggregating data. Here are some of the most commonly used ones:

  1. "Where" : Filters a collection based on a specified condition.

  2. "Select": Projects each element in a collection to a new value.

  3. "OrderBy or OrderByDescending" : Sorts a collection in ascending or descending order based on a key.

  4. "Skip and Take" : Skips a certain number of elements and takes a specific number of elements from the beginning of a collection.

  5. "Any and All": Checks if any or all elements in a collection meet a certain condition.

  6. "Sum, Average, Count, Min, and Max": Perform aggregate operations on collections.

Benefits of Using LINQ in Unity :

  1. Code Readability :
    LINQ's syntax often resembles natural language, making your code easier to understand and maintain.

  2. Conciseness :
    Common data manipulation tasks can be expressed in a single line of LINQ code, reducing code clutter compared to traditional loops.

  3. Type Safety :
    LINQ leverages C#'s type system, helping to prevent errors and improve code reliability.

LINQ in Action: Let's Get Practical :

post 2

Okay, enough talk, let's see LINQ in action! Here are some common tasks in Unity that LINQ can make a breeze :

  1. Finding Stuff :
    Need to locate all the enemies within a specific radius of your player? LINQ can filter your enemy list with ease.

    2.   
Traditional Loop Approach:-
--------------------------

List enemiesInRange = new List();
  foreach (GameObject enemy in allEnemies)
  {
    float distance = Vector3.Distance(player.transform.position, enemy.transform.position);
    if (distance<= attackRange)
    {
      enemiesInRange.Add(enemy);
    }
  }
  
  LINQ Approach (using Where):-
  ----------------------------

  List enemiesInRange = allEnemies
    .Where(enemy => Vector3.Distance(player.transform.position, enemy.transform.position) <= attackRange)
    .ToList();

    Here, LINQ's Where clause filters the allEnemies list and returns only those enemies within the specified distance. This is cleaner and more concise than a traditional loop

  2. Sorting Things Out :
    Want to organize your items based on their value or rarity? LINQ can sort your list in a snap.

    3.   
Traditional Loop Approach:-
--------------------------

// This can get messy with complex sorting logic!
List sortedItems = new List(allItems);
// Implement sorting logic using loops and comparisons

  
  LINQ Approach (using Where):-
  ----------------------------

  List sortedItems = allItems.OrderBy(item => item.rarity).ToList();

    This snippet uses OrderBy to sort the allItems list based on their rarity property. You can even chain OrderByDescending to sort in descending order.

  3. Transforming Data:
    Need to calculate damage based on player stats? LINQ can manipulate your data with a few lines of code.

    4.   
Traditional Loop Approach:-
--------------------------

int damage = 0;
// Loop to calculate base damage based on attack power
// Loop to add random factor

damage = player.attackPower * Random.Range(0.8f, 1.2f); // Example calculation

  
  LINQ Approach (using Where):-
  ----------------------------

  int damage = player.attackPower * Random.Range(0.8f, 1.2f);

  // Lambda expression to calculate damage for each player
  List playerDamages = players.Select(player => player.attackPower * Random.Range(0.8f, 1.2f)).ToList();

    This example uses Select with a lambda expression to create a new list containing the calculated damage for each player in the players list. Lambda expressions allow for concise anonymous functions within LINQ queries.

Using LINQ in Unity:

C# is a programming language, and LINQ is a feature of C# that helps us work with data in a more fun and easy way. With LINQ, we can write fewer lines of code and still get powerful results. It’s like a shortcut to make our programs work smarter, not harder!

In Unity, we can use LINQ to do cool things like finding objects in a game scene or organizing data. For example, if you’re making a game with lots of enemies, you can use LINQ to find all the enemies that are close to your character and make them go away with a single line of code. How awesome is that?

LINQ and Collections:

In programming, we often work with collections of things like lists or arrays. LINQ can help us do amazing things with these collections.With LINQ, we can perform powerful operations on these lists and make our game development tasks much simpler.

  1. with LINQ:
    Let’s say we have a list of monsters, and we want to find all the scary ones. With LINQ, we can do this easily. Here’s how:

    2.   
var scaryMonsters = monsterList.Where(monster => monster.IsScary);

    In this example, monsterList is our list of monsters, and IsScary is a property that tells us if a monster is scary or not. LINQ's Where function helps us filter the list based on this condition, and the result is stored in the scaryMonsters list. How cool is that?

  2. Sorting with LINQ:
    Now, let’s imagine we have a bunch of different fruits, and we want to sort them alphabetically. LINQ can help us with that too :

    3.   
var sortedFruits = fruitList.OrderBy(fruit => fruit.Name);

    In this case, fruitList is our list of fruits, and Name is a property that holds the name of each fruit. LINQ's OrderBy function arranges the fruits in alphabetical order based on their names, and the sorted result is stored in the sortedFruits list.

  3. Filter game objects :
    Filter game objects by tag, layer, or component presence:

    4.   
List< GameObject> interactableObjects = FindObjectsOfType< GameObject>()
  .Where(go => go.GetComponent< IInteractable>() != null)
  .ToList(); // Find all objects with the IInteractable component
post 2

Examples :

    1. Let’s imagine you have a group of friends, and you want to find all the friends whose names start with the letter “A” using LINQ.

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

public class Program
{
    public void MyFriends()
    {
        List friends = new List { "Aman", "Boby", "Amit", "Gaurav", "Sarah" };

        var friendsStartingWithA = friends.Where(friend => friend.StartsWith("A"));

        foreach (var friend in friendsStartingWithA)
        {
            Debug.Log(friend);
        }
    }
}

  1. In this example, we have a list of friends (friends). We want to find all the friends whose names start with the letter "A". Using LINQ, we use the Where command and provide a condition inside the parentheses. The condition checks if each friend's name starts with the letter "A" using the StartsWith method.

  2. The result of this LINQ query is a new collection (friendsStartingWithA) that contains only the friends whose names start with "A" ("Alice", "Amy", and "Alex" in this case). We then iterate over this collection using a foreach loop and print each friend's name to the console.


    2. Let’s consider a scenario where we have a list of game objects representing enemies, and we want to find all the enemies that are within a certain range from the player’s position using LINQ.

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

public class Enemy : MonoBehaviour
{
    public string Name { get; set; }
    public Vector3 Position { get; set; }
}

public class Player : MonoBehaviour
{
    public Vector3 Position { get { return transform.position; } }
}

public class GameManager : MonoBehaviour
{
    public List enemies;

    void Start()
    {
        // Assuming enemies list is populated with enemy objects

        float detectionRange = 10.0f;
        Player player = FindObjectOfType();

        var nearbyEnemies = enemies.Where(enemy => Vector3.Distance(enemy.Position, player.Position) <= detectionRange);

        foreach (var enemy in nearbyEnemies)
        {
            Debug.Log("Enemy: " + enemy.Name);
        }
    }
}

  1. In this example, we have a GameManager class that contains a list of Enemy objects (enemies). Each enemy has a name and a position represented by a Vector3. We also have a Player class that has a position.

  2. We want to find all the enemies that are within a certain range (in this case, detectionRange) from the player's position. Using LINQ, we apply the Where command to filter the enemies based on the condition that the distance between the enemy's position and the player's position is less than or equal to the detection range.

  3. The result of this LINQ query is a new collection (nearbyEnemies) that contains the enemies that are within the specified range. We then iterate over this collection using a foreach loop and log the names of the nearby enemies.


    3. Let's consider a scenario where we have a list of students, and we want to find all the students who have scored above a certain threshold using LINQ.

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

public class ScoreManager
{
    void Start()
    {
        CalculateScore();
    }

    public   void CalculateScore()
    {
        List Players = new List
        {
            new Player { Name = "Aman", Score = 85 },
            new Player { Name = "Bablu", Score = 76 },
            new Player { Name = "Cara", Score = 92 },
            new Player { Name = "Dara", Score = 80 },
            new Player { Name = "Emily", Score = 88 }
        };

        int threshold = 80;

        var highScoringPlayers = Players.Where(player => player.Score > threshold);

        foreach (var player in highScoringPlayers)
        {
            Debug.Log(player.Name);
        }
    }
}

public class Player
{
    public string Name { get; set; }
    public int Score { get; set; }
}

  1. In this example, we have a list of player objects (players), where each player has a name and a score. We want to find all the players who have scored above a certain threshold (in this case, 80). Using LINQ, we apply the Where command to filter the players based on the condition that their score is greater than the threshold.

  2. The result of this LINQ query is a new collection (highScoringPlayers) that contains the students who have scored above the threshold. We then iterate over this collection using a foreach loop and print the names of the high-scoring players to the console.

Conclusion :

LINQ is a super cool and powerful tool that helps us do amazing things with code. We can ask questions, search for things, and make our programs work smarter and faster. Whether you’re creating a game or building an app, LINQ can be your secret weapon!

See, LINQ isn’t as scary as it sounds! It’s a powerful tool that helps us search, sort, and transform data with just a few lines of code. Next time you’re building a game in Unity with C#, remember to give LINQ a try. It’ll make your coding life much easier and more fun!


I hope you found this blog post enjoyable!


More Blogs

See All