DEV Community: Niraj Vishwakarma

Mastering SOLID Principles in Unity Game Development - New Course Launch

Niraj Vishwakarma — Tue, 04 Nov 2025 16:09:41 +0000

I've been working on for quite some time - my new course, "Mastering SOLID Principles in Unity Game Development"

Over the past decade of working as a Unity Game Developer and VR Specialist, I've realized that writing code that works and writing code that lasts are two very different things. Many of us start our game development journey full of enthusiasm, only to hit roadblocks as projects grow - messy dependencies, unreadable scripts, unexpected bugs, and deadlines that suddenly feel impossible.

That's where clean code principles come into play - and among them, the SOLID principles stand out as a timeless foundation. They not only help us structure our projects better but also make collaboration, scaling, and debugging so much easier.

This course was born out of that realization.
I wanted to create something simple, practical, and relatable for Unity developers who wish to level up their understanding of code architecture - not through heavy theory, but through hands-on Unity examples that reflect real game dev scenarios.

Here is the Course Link: Mastering SOLID Principles in Unity Game Development

In this course, you'll explore:

Common problems developers face when no clear coding guidelines are followed

How each SOLID principle improves flexibility and maintainability

Step-by-step implementation of SOLID principles inside Unity

A sample mini-project that ties all principles together into a modular, scalable structure

My goal is simple - to make developers confident in their codebase and design approach. Whether you're a junior developer looking to grow or a seasoned coder aiming to polish your architectural mindset, I hope this course brings you value in your daily development work.

If you decide to take the course, I'd love to hear your thoughts and experiences. You can connect with me on LinkedIn or drop me a quick email at Nirajv21@gmail.com - even if it's just to say a friendly Hi!

Here's to writing better code, building better games, and learning something new every day.

Warm regards,
Niraj Vishwakarma
Unity Game & XR Developer

Pixel-Perfect UI in Unity: A Complete Guide for Designers and Developers

Niraj Vishwakarma — Tue, 01 Jul 2025 19:36:27 +0000

If you're part of a game or app team using Unity, you’ve probably faced this common issue:

“The design looked perfect in Figma or Photoshop…
But inside Unity? Everything is slightly off — icons look blurry, UI is misaligned, Spine animations don’t match their intended size.”

This problem costs teams hours of frustration and rework. Designers do their best, developers try to match by ‘eyeballing’… and no one’s really satisfied.

In this blog post — and the accompanying video tutorial — we’ll walk you through a practical pipeline that aligns both sides of the table: UI/UX Designers and Unity Developers.
Together, we’ll build a system where the design is implemented exactly as it was envisioned, every time.

What This Guide Covers:

We break down the full workflow into digestible, actionable sections.

Printable PDF of the Guideline

Pixel Perfect Graphics Pipeline in Unity – Design to Dev Handoff Guide - Speaker Deck

Presenting the ultimate guide for a seamless handoff between UI/UX designers and Unity developers, covering everything you need to create pixel-perfect …

speakerdeck.com

Example Based Explanation Video for Guideline

1. Understanding the Problem

Why mockups often don’t match Unity screens
Common causes: scaling, camera size, missing specs, inconsistent export

2. The Role of PPU (Pixels Per Unit)

How to decide and standardize PPU (e.g., 100)
How PPU affects object size inside Unity’s world or Canvas

3. Camera Setup That Matches Design Resolution

Using Unity’s orthographic camera with the right orthographicSize setting
Formula to match mockup resolution like 1920x1080 to Unity’s camera units

4. Designer Kickoff and Export Guidelines

Designing at native resolution
Avoiding export scaling or image compression
Planning for 9-slicing and reusable UI components

5. The Handoff Process

Using tools like Figma, Zeplin, or Adobe XD
How developers can inspect, download, and measure directly from design files

6. Spine Animation Best Practices

How to scale Spine characters accurately in Unity
Difference between SkeletonAnimation (world space) and SkeletonGraphic (Canvas)
Tips for designing Spine assets with Unity units in mind

7. Packing Assets the Right Way

Why you should use TexturePacker
How to create atlases for optimal draw call performance
Maintaining pixel fidelity while improving runtime efficiency

8. Developer Implementation Best Practices

Setting up UI Canvas correctly (Canvas Scaler, RectTransforms)
Importing sprites with correct PPU, filter mode, compression
Never scale assets manually to fix things — fix the pipeline

Final Thoughts

A seamless handoff between design and development isn’t just about tools — it’s about clarity, consistency, and communication.

By locking down a few shared standards like resolution, PPU, and export methods, your team can drastically reduce wasted time and finally bring the design vision to life, pixel by pixel.

Multiplayer VR Development using Unity XR Interaction Toolkit and Photon Fusion 2

Niraj Vishwakarma — Thu, 01 May 2025 10:47:43 +0000

This blog post is taken from the book Unity for Multiplayer VR Development. Check my other books at Amazon Author Page.

With VR technology becoming more affordable and realistic, we’re witnessing a rise in Metaverse and Social VR applications across various industries. Users from around the world can now connect in shared virtual spaces, talk via voice chat, and interact with common elements in a collaborative environment. Whether you're a developer exploring new technology, creating a demo for a client, or working on your next business idea, building a Social VR experience is more achievable than ever.

This blog will help you take the first steps and plan your journey in the right direction.

The Evolving Use Cases of VR

Like every emerging technology, VR initially went through a hype phase. While that hype is still alive, VR is now steadily gaining traction in real-world applications. From defense training, medical simulation, and safety drills, to manufacturing training and virtual tourism, the list of use cases continues to grow. Major brands like Meta, Apple, HTC, PICO are releasing new devices, and there is significant investment pouring into the space.

Roadmap to Building a Social VR Experience

Let’s outline a basic roadmap to develop VR Metaverse applications. These are core features that are practically essential for most social VR platforms:

✅ Feature 1: VR Avatars Can Join a Multiplayer Session
Create networked sessions where multiple users can join the same virtual environment.

✅ Feature 2: VR Avatars Can See Other Joined Avatars
Enable full-body or head-hand avatars so that users can see each other’s presence in real time.

✅ Feature 3: VR Avatars Can Communicate with Voice Chat
Integrate voice chat so users can talk naturally, as they would in the real world.

✅ Feature 4: VR Avatars Can Interact with Interactable Items
Add interactive elements (like doors, levers, tools, or whiteboards) that users can use collaboratively.

Tech Stack We'll Use

To implement these features, we’ll use the following tools:

Game Engine: Unity
VR Interaction SDK: XR Interaction Toolkit with OpenXR (for cross-platform compatibility)
Multiplayer SDK: Photon Fusion 2 (for performant and flexible networking)

Let us elaborate each feature in detail for it's implementation using mentioned tech stack.

Feature 1: VR Avatars Can Join a Multiplayer Session

This feature enables users to enter a shared virtual environment where they can interact with other players in real-time. It forms the backbone of the multiplayer experience, requiring a robust networking infrastructure to manage player connections and session handling.

Technical Requirements:

Implement Photon Fusion 2.0 to manage the multiplayer framework. Photon Fusion will handle the creation and joining of sessions, player synchronization, and real-time communication between clients.
Develop a lobby or matchmaking system using Photon Fusion’s capabilities, allowing players to either create new sessions or join existing ones with minimal latency.

Feature 2: VR Avatars Can See Other Joined Avatars

Visual representation of other players is crucial for immersion in a multiplayer VR environment. This feature allows users to see and interact with avatars representing other players, enhancing the sense of presence.

Technical Requirements:

Utilize Photon Fusion 2.0 to synchronize avatar states across the network, ensuring that all players see each other’s movements and actions in real-time.
Implement an avatar system that accurately reflects head, hand, and body movements. Photon Fusion will manage the spawning and synchronization of avatars, ensuring they are consistently displayed across all connected clients.

Feature 3: VR Avatars Can Communicate with Voice Chat

Voice communication is vital for social interaction and collaboration in multiplayer VR. This feature allows players to speak to each other in real-time, adding a layer of realism and enhancing the overall experience.

Technical Requirements:

Integrate Photon Voice, a module of Photon Fusion, to enable real-time voice chat. Photon Voice will handle audio transmission between players, ensuring low latency and clear communication.
Implement features such as proximity-based voice chat, where players’ voices become louder or softer depending on their virtual distance, adding a sense of realism to the communication.

Feature 4: VR Avatars Can Interact with Interactable Items

Interaction with virtual objects is a key component of immersive VR experiences. This feature allows avatars to manipulate and interact with various items within the environment, making the virtual world more dynamic and engaging.

Technical Requirements:

Leverage the XR Interaction Toolkit to define and create interactable items within the VR environment. Implement interaction logic such as grabbing, moving, or activating items.
Use Photon Fusion 2.0 to synchronize these interactions across all players in the session. When one player interacts with an item, the changes should be reflected in real-time for all connected players, ensuring a consistent experience.

Roadmap for Development

The development roadmap will focus on identifying key entities central to the project and breaking them down into individual features. Each feature will be connected to the tools and components required for implementation. As outlined in the project scope, we will focus on two major entities: VR Player Entity and Interactable Item Entity. These will serve as the core around which supporting classes and scripts, such as UI screens and manager classes, will be developed.

1. VR Player Entity

The VR Player Entity represents the user in the multiplayer VR environment. It will handle avatar representation, movement, interactions, and communication.

Here are the tasks required for the development of the VR Player Entity, with each task focused on implementing a specific feature using the designated tool:

XR Rig Setup:

Feature: Set up an XR Rig using the XR Interaction Toolkit SDK, allowing players to navigate the environment via teleportation using VR controllers.
Tools: XR Interaction Toolkit.

Networked Player Movement:

Feature: Implement real-time networked movement using Photon Fusion 2.0, ensuring the player's movements are synchronized across all connected users.
Tools: Photon Fusion 2.0.

Synchronized Movement of Player's Head and Hands:

Feature: Ensure the VR player's head and hand movements are tracked and synchronized across the network for other players to see in real-time.
Tools: Photon Fusion 2.0, Unity’s XR Interaction Toolkit for head and hand tracking.

Interaction with Objects:

Feature: Allow players to pick up and manipulate interactable objects within the environment using the XR Grab Interactable component from the XR Interaction Toolkit SDK.
Tools: XR Interaction Toolkit, Photon Fusion 2.0 (for network synchronization).

Voice Communication:

Feature: Enable real-time voice communication between players using Photon Voice to create a seamless social experience.
Tools: Photon Voice SDK, Unity Audio system.

2. Interactable Item Entity

The Interactable Item Entity defines objects that players can interact with, such as picking up and moving these items. These objects will react based on the player's actions, providing feedback in the virtual world with sound and colour.

Here are the tasks required for the development of the Interactable Item Entity, with each task focused on implementing a specific feature using the designated tool:

Interactable Objects Configuration:

Feature: Configure interactable items using the XR Interaction Toolkit's XR Grab Interactable component, allowing items to be picked up, thrown, or used by the player.
Tools: XR Interaction Toolkit, Photon Fusion 2.0 (for multiplayer synchronization).

Attachment Points:

Feature: Create predefined attachment points on interactable objects. These points will define the exact position and orientation of objects when grabbed by the player, ensuring consistent handling and placement.
Tools: XR Interaction Toolkit.

3. Supporting Components

While the VR Player Entity and Interactable Item Entity are central to the development, the project will also include:

UI Screens for interaction and player settings (using Unity’s UI Toolkit).
Manager Classes to handle game sessions, player management, and voice communication setup.

The complete development for the above Roadmap has been covered in the book Unity for Multiplayer VR Development which is available at Amazon and Amazon India. Get your copy to get clear explanation for each component required for Multiplayer VR experience development.

Ultimate Unity for Multiplayer VR Development — now available!

Niraj Vishwakarma — Sat, 26 Apr 2025 10:20:03 +0000

🏁 Lights out and away we go with my Second Book Launch! 🏁
Super excited to announce the release of my latest book —
Ultimate Unity for Multiplayer VR Development — now available!

This hands-on guide is your ultimate companion for building immersive multiplayer VR experiences using Unity XR Interaction Toolkit and Photon Fusion. Whether you're a Unity developer, VR enthusiast, or game designer, this book will help you bring cross-platform VR worlds to life with confidence and clarity.

👉 What’s Inside?

● Explore XR evolution, hardware, software, and key development tools.
● Learn multiplayer networking fundamentals for XR applications.
● Build and deploy interactive VR experiences using Unity.
● Implement Photon Fusion for seamless multiplayer VR networking.
● Create networked VR avatars with voice chat and interactions.
● Optimize and deploy high-performance XR applications efficiently.

🏗️ Also, before jumping into the practical project, the book provides a detailed, ground-up discussion on Networking, XR Interaction Toolkit, and Photon Multiplayer SDK — setting a strong foundation before you build your own multiplayer VR experience from scratch!

✳ 𝐆𝐞𝐭 𝐘𝐨𝐮𝐫 𝐂𝐨𝐩𝐲 𝐍𝐨𝐰! ✳
👉 For International Buyers (AVA): https://orangeava.com/products/ultimate-unity-for-multiplayer-vr-development

👉 For Indian Buyers (AVA): https://orangeava.in/products/ultimate-unity-for-multiplayer-vr-development

👉 Amazon International: https://www.amazon.com/Ultimate-Unity-Multiplayer-Development-High-Performance/dp/B0F3N6GL13/

👉 Amazon India: https://www.amazon.in/Ultimate-Unity-Multiplayer-Development-High-Performance/dp/9348107437/

Applying MVC Architecture in Game Development

Niraj Vishwakarma — Tue, 22 Apr 2025 17:50:53 +0000

This post is an excerpt from the book Learning Game Architecture with Unity. Check my other books at Amazon.

Selecting the right architecture for a game project is crucial for its success and maintainability. Depending on the project's scope, complexity, and goals, several architectural approaches can be considered, mentioned as follows:

No architecture: For simpler projects or prototypes, a formal architecture might be overkill. In these cases, keeping things straightforward without imposing a structured framework can be practical. This approach allows for rapid development and iteration, ideal for small-scale projects where complexity is minimal, and requirements are likely to change frequently.
Custom architecture: As projects grow in size and complexity, a custom architecture might be designed to address specific needs. This approach allows developers to create a tailored solution that fits the unique requirements of the project. However, designing a custom architecture requires careful planning and consideration to ensure it effectively manages the complexity and scales with the project.
Proven architectures: For larger and more complex projects, leveraging established architectural patterns can be highly beneficial. Proven architectures like MVC, MVP, and MVVM provide well-defined frameworks that promote separation of concerns, modularity, and maintainability. These architectures are tested and refined, offering a solid foundation for managing intricate game mechanics and interactions.

MVC is one of the most widely adopted architectural patterns, known for its effective separation of concerns and flexibility. By exploring MVC, we will understand how it organizes game components into distinct layers, Model, View, and Controller, and how this separation enhances code maintainability and scalability.

Understanding MVC/MVCS architecture

The MVC architecture is a classic design pattern used to separate concerns in software development, making it easier to manage and scale applications. Let us break down the key areas of concern in MVC and its application in game development:

Model: The Model represents the data and the business logic of the application. It manages the state of the game, handles data storage, and processes game logic. In a game, the Model could be responsible for managing player statistics, game state, and other core data.
View: The View is responsible for rendering the user interface and presenting the data from the Model to the user. It displays information such as game graphics, user interfaces, and other visual elements. In Unity, the View typically corresponds to MonoBehaviours that handle visual aspects and render updates based on the data provided by the Model.
Controller: The Controller handles the input from the user, processes it, and updates the Model accordingly. It acts as an intermediary between the View and the Model, ensuring that user interactions are translated into changes in the game state. In classic MVC, the Controller directly handles user input and updates the Model.

MVC in Unity

In Unity, the roles of View and Controller are slightly adapted due to the engine's architecture and design. Here is how Unity handles these components:

View: In Unity, MonoBehaviours are often used for handling user input and rendering. The View is responsible for capturing user interactions, such as button clicks or movement inputs, and updating the game’s visual representation accordingly. This approach leverages Unity’s component-based architecture to manage game visuals and inputs directly.
Controller: Instead of handling input directly, the Controller in Unity processes the input captured by the View. The Controller takes the user input from the View and translates it into actions that modify the Model. This separation allows for a more modular design where input handling and game logic are distinctly managed.

From Classic MVC to MVCS

Modern games often communicate with servers and external services to handle additional data and functionalities. To accommodate these needs, the classic MVC architecture is extended to MVCS, where an additional layer, Services, is introduced. Here is how MVCS enhances MVC:

Services layer: This layer interacts with backend services, external APIs, or databases to manage external data and server communication. It handles tasks such as fetching game data from a server, managing user accounts, or processing in-game transactions.
Integration with MVC: In the MVCS architecture, the Services layer works alongside the Model, View, and Controller. The Controller interacts with the Services layer to retrieve or send data, which then updates the Model. The Model reflects these changes in the View, ensuring that the game remains synchronized with external data sources.

The new architecture with the Service layer added is shown below:

It is essential to highlight that in an MVC architecture within Unity, there can be multiple Models, Views, and Controllers. This flexibility allows each component to handle different aspects of the game separately. For instance, you might have a PlayerModel, EnemyModel, and WeaponModel, each with corresponding Views and Controllers. This modularity not only keeps your codebase clean and organized but also enables you to expand or modify individual components without affecting the entire system. This setup is particularly beneficial in complex games where different systems need to interact while remaining decoupled. Refer to the following figure:

This separation not only made the codebase more manageable but also allowed for easier testing and future modifications. Each component could be developed and tested independently, reducing the risk of introducing bugs when making changes. For example, the developer could easily adjust the firing logic in the Controller without affecting the weapon's visual representation in the view.

Application of MVC architecture has been covered with great details in the book: Learning Game Architecture with Unity, which is available @ Amazon, Amazon India, BPB International, BPB India.

Beyond If-Else Hell: Elegant State Machine pattern in Game Development

Niraj Vishwakarma — Thu, 17 Apr 2025 16:39:23 +0000

This post is an excerpt from the book Learning Game Architecture with Unity. Check my other books at Amazon.

The State pattern is a behavioral design pattern that allows an object to alter its behavior when its internal state changes. This pattern is particularly useful when an object's behavior depends on its state and must change dynamically at runtime.

Defining State

State can be defined as the current condition of an object or system, i.e., the state decides the behaviour of an object or system. For example:

Time of the day: Morning, Day, Afternoon, Evening, Night
Current whether states: Sunny, Snowing, Raining
Character physical states: Idle, Walking, Sleeping, Chasing, Hiding, Healthy, Hurt

Defining state machine

A state machine is a behavioral model that comprises a finite number of states, hence it is also referred to as a finite state machine (FSM). It operates based on the current state and a specified input, facilitating state transitions, and generating corresponding outputs.

When an input is received, the state machine transitions from its current state to a new state based on predefined rules or transitions defined by the system's design. These transitions dictate how the system responds to different inputs or conditions.

Important components of a State

In general, there are three key points for every state class which helps define the overall behavior of the state:

State entry
Update loop
State exit

Let us take a look at each of them:
Entry:

The entry point of a state is where initialization or setup tasks are performed when the object or system transitions into that state.
It typically involves setting up initial variables, initializing state-specific resources, or performing any necessary setup actions.
Entry actions are executed only once when the state is first entered.

Exit:

The exit point of a state is where cleanup or finalization tasks are performed when the object or system transitions out of that state.
It involves releasing resources, resetting variables, or performing any necessary cleanup actions to prepare for transitioning to a new state.
Exit actions are executed only once when the state is about to be exited.

Update loop:

The update loop represents the main processing logic or behavior of the state, which is executed continuously while the object or system remains in that state.
It defines the actions, behaviors, or calculations that repeatedly occur within the state.
The update loop is where the state's core functionality or behavior is implemented.

Let us take an example of a table lamp and break down its behaviour into a state machine:

Another interesting example can be the state of an AI or NPC agent in a game scenario. The agent's behavior may change based on whether it can see the player. In such a situation, a state machine can manage the agent's states and transitions, allowing it to focus on specific behaviors within each state.

Following are the states of the AI bot:

Sleep: Initial state where the AI bot is not actively engaged in any action.
Patrol: The AI bot is walking around the environment.
Chase: The AI bot is actively chasing the player once they are in visible range.
Hurt: The AI bot is being attacked by the player.

Following are the state transitions of an AI bot:

Sleep |→ Patrol: Transition to a walking state when the AI bot starts patrolling or moving around.
Patrol |→ Chase: Transition to chasing state when the player becomes visible within the AI bot's range.
Chase |→ Patrol: Transition to patrol state when the player goes out of sight of the AI Bot.

By defining these key components for each state class, the overall behavior of the state machine can be clearly delineated, facilitating modular design and maintainability. Each state encapsulates its specific behavior, allowing for easier comprehension, modification, and extension of the system's functionality.

Next, we will look at how we can implement a state machine for a given problem. We want to implement a state machine to control a character controller with various states such as attacking, defending, and returning home.

Implementing state machine using inheritance

The steps to be followed for implementing state machine using inheritance are as follows:

Define a base state class.
Create Separate classes for each concrete state, inheriting the base state class.
State Machine will manage transition among different states.

// Creating base state

public abstract class CharacterState
{
    public abstract void EnterState(CharacterController controller);
    public abstract void Update(CharacterController controller);
    public abstract void ExitState(CharacterController controller);
}

// Creating Concrete states inheriting Base State

public class AttackingState : CharacterState
{
    public override void EnterState(CharacterController controller)
    {
        // Enter Attacking state logic
    }

    public override void Update(CharacterController controller)
    {
        // Attacking state logic
    }

    public override void ExitState(CharacterController controller)
    {
        // Exit Attacking state logic
    }
}

Similarly, other states like ReturningHomeState can be implemented. Next, we will implement a CharacterController in which state transition logic will be implemented, as shown:

// Character Controller class

public class CharacterController
{
    private CharacterState currentState;

    public void ChangeState(CharacterState newState)
    {
        if (currentState != null)
        {
            currentState.ExitState(this);
        }

        currentState = newState;
        currentState.EnterState(this);
    }

    public void Update()
    {
        if (currentState != null)
        {
            currentState.Update(this);
        }
    }
}

The CharacterController class manages the current state and transitions between states based on external events or conditions. This approach allows for flexible and modular design, making it easier to add, remove, or modify states as needed.

Game design patterns and their usage are explained in the the context of game development with great details in the book: Learning Game Architecture with Unity, which is available @ Amazon, Amazon India, BPB International, BPB India.

Isolate and Control: The Singleton's Role in Game Architecture

Niraj Vishwakarma — Sat, 12 Apr 2025 04:25:19 +0000

This post is an excerpt from the book Learning Game Architecture with Unity

The Singleton design pattern is a creational pattern that ensures a class has only one instance and provides a global point of access to that instance. This pattern is particularly useful when we need to restrict the instantiation of a class to a single object. In many scenarios, such as managing resources or controlling access to shared data, having only one instance of a class is beneficial. For example, manager classes like AudioManager, InputManager, or DBConnectionManager often need to perform specific tasks throughout the project. By implementing these classes as singletons, we ensure that they can be accessed from anywhere in the project and maintain only one instance at runtime.

Overall, the Singleton pattern facilitates efficient resource management and ensures consistent behaviour across the application by guaranteeing that only one instance of the class exists at any given time. It is a powerful tool for organizing and controlling access to shared resources in a software project.

The debate surrounding the usage of the Singleton pattern is indeed prevalent among developers, highlighting the importance of carefully considering its advantages and disadvantages in the context of each project. While the Singleton pattern can offer benefits such as centralized access to manager classes and ensuring a single instance of a particular object, its suitability may vary based on the evolving requirements and design considerations of the project.

Implementing the Singleton pattern

The Singleton pattern can be implemented in two main ways:

Individual Singleton check in each class
Utilizing a generic Singleton base class

1. Individual Singleton check in each class

In this approach, each class independently manages its singleton instance by incorporating a singleton check within its codebase.

public class AudioManager : MonoBehaviour {

    public static AudioManager _instance {get; private set;}

    private void Awake() {
       // checking for single instance
    If(_instance == null)
        _instance = this;
    else
        Destroy(this.gameobject);
    }

    Public void PlayAudio(Audioclip _clip)
    {
    // Play Audio here
    }
}

Now, AudioManager can be accessed from anywhere in the project simply by calling AudioManager._instance.PlayAudio(clip). Similarly, the Singleton pattern can be applied to other manager classes such as InputManager **and **DBConnectionManager. In each of these classes, a singleton instance check can be included within the Awake method to ensure that only one instance exists throughout the project.

2. Utilizing a generic Singleton base class

In the earlier implementation approach, we observed repetitive code within the **Awake **method of each class to create a singleton instance. However, this process can be streamlined and made more modular by introducing a generic base singleton class. By extending this base class, other classes can effortlessly establish themselves as singletons.

// Base Singleton Class
public class Singleton<T> : MonoBehaviour where T : Singleton<T>
{
    private static T _instance {get; private set;}

    private void Awake()
    {
        if (_instance == null)
        {
            instance = this as T;
            DontDestroyOnLoad(this );
        }
        else
        {
            Destroy(this);
        }
    }
}

By extending the base singleton class, other classes such as AudioManager, InputManager, and DBConnectionManager can effortlessly become singletons without the need for local instance checking as shown:

public class AudioManager : Singleton<AudioManager>
{
    public void PlayAudio(AudioClip _clip)
    {
        // Play Audio here
    }
}


public class InputManager : Singleton<InputManager>
{
    ---
}

public class DBConnectionManager : Singleton<DBConnectionManager>
{
    ---
}

Now, these managers can be accessed from anywhere in the project using the static _instance variable. For example:
- AudioManager._instance.SomeMethod(),
- InputManager._instance.SomeMethod(),
- DBConnectionManager._instance.SomeMethod()

Game design patterns and their usage are explained in the the context of game development with great details in the book: Learning Game Architecture with Unity, which is available @ Amazon, Amazon India, BPB International, BPB India.

Beyond Spaghetti Code: Mastering Game Design Patterns

Niraj Vishwakarma — Thu, 10 Apr 2025 17:31:03 +0000

This post is an excerpt from the book Learning Game Architecture with Unity

In the dynamic world of software development, where complexity is inherent and requirements constantly evolve, the importance of employing efficient, scalable, and maintainable solutions cannot be overstated. This is where design patterns step in as invaluable tools for developers seeking to streamline their workflows and enhance the quality of their code. In this chapter, we will delve into the realm of design patterns within the context of Unity.

Gang of Four and design patterns

The Gang of Four design patterns emerged as a response to the recurring challenges inherent in software design and development. Introduced in the influential book Design Patterns: Elements of Reusable Object-Oriented Software in 1994, authored by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides—collectively referred to as the Gang of Four—these patterns represent a comprehensive set of solutions aimed at addressing common issues encountered in software engineering.

The patterns are systematically organized into three primary groups:

1. Creational patterns: Creational design patterns deal with object creation mechanisms, aiming to increase flexibility and reuse of existing code. These patterns abstract the instantiation process and provide a way to create objects while hiding the creation logic, making the system more manageable and scalable. For example, in a game, you often need to create different types of enemies based on the level or environment. Instead of manually writing new statements for each enemy type, a Factory Method provides a centralized way to create objects, ensuring that the game remains easy to maintain and extend.

2. Structural patterns: Concerned with object composition and class structure, structural patterns facilitate the creation of flexible and efficient software architectures. Patterns like Fly Weight, Composite, and **Decorator **enable the composition of objects into larger structures while maintaining the system's integrity and adaptability to change.

3. Behavioural patterns: Behavioural patterns govern the interaction and communication between objects, defining how they collaborate to accomplish tasks. Patterns such as Observer, State, and **Command **encapsulate algorithms, behaviours, and communication strategies, promoting loose coupling and extensibility in software designs.

In summary, the Gang of Four Design Patterns offer a comprehensive toolkit for software designers and developers, enabling them to create more robust, modular, and maintainable software systems. Through their systematic organization and reusable solutions, these patterns continue to shape modern software development practices, serving as foundational principles for building high-quality software.

We will see them in details in upcoming blogs with their implementation.

Game design patterns and their usage are explained in the the context of game development with great details in the book: Learning Game Architecture with Unity, which is available @ Amazon, Amazon India, BPB International, BPB India.

SOLID design principles in Game Development

Niraj Vishwakarma — Sun, 06 Apr 2025 13:30:09 +0000

This post is an excerpt from the book Learning Game Architecture with Unity

Design principles in game development are fundamental guidelines that dictate the process of creating clean, maintainable, and scalable code. They are essential for crafting robust, adaptable, and high-quality software systems. These principles act as the building blocks upon which developers construct their code, guiding the architectural decisions and coding practices to achieve better code quality and maintainability.

By following design principles, developers create code that is more adaptable to changes, as it becomes easier to refactor, debug, and extend without causing unintended consequences or introducing bugs. These principles encourage a structured approach to coding, promoting separation of concerns, maintainability, and code that is easier to test and debug.

Need for software design principles

Imagine a team developing a complex multiplayer game. Initially, the code lacks adherence to clean code principles. As the project advances, new features like character customization, interactive environments, and diverse gameplay mechanics are added, causing the codebase to grow in complexity.

Problems without clean code practices would be:

Maintenance nightmare: Developers find it hard to make changes or add features without inadvertently causing issues elsewhere. Even a small modification could lead to unexpected bugs in other parts of the game.
Increased bugs: With intricate and tangled code, the likelihood of introducing bugs rises significantly. The complexity makes it harder to test thoroughly, leading to more hidden issues.
Collaboration hurdles: The team struggles to collaborate efficiently due to the lack of clear code. Understanding and integrating contributions from different developers becomes time-consuming and error-prone.
Scalability challenges: As the game evolves, maintaining and extending functionalities becomes increasingly cumbersome. The codebase becomes a hindrance, slowing down the addition of new features.

Popular software design principles

Clean code transcends language-specific rules; it applies universally across diverse software languages, even those used in gaming projects. These design principles remain language-agnostic in their application. Refer to the following figure:

SOLID principles: This set of five principles (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) focuses on creating more maintainable, flexible, and understandable software systems.
Keep It Simple, Stupid (KISS): Emphasizes simplicity in design and development, advocating for straightforward solutions over complex ones.
Don't Repeat Yourself (DRY): Encourages the elimination of redundant code to enhance maintainability by reusing existing code.
You Aren't Gonna Need It (YAGNI): Advises against adding functionality or code until it is necessary, avoiding unnecessary complexities.

Among the pantheon of widely recognized design principles, the SOLID principles stand as a bedrock, renowned for their effectiveness in shaping resilient and scalable software architectures.

SOLID design principles

The SOLID principles, a fundamental set of design principles in software engineering, encapsulate a structured approach to crafting robust, maintainable, and adaptable codebases. Coined by Robert C. Martin, these principles serve as foundational pillars guiding developers toward writing flexible, scalable, and comprehensible software.

Here is a concise summary of each principle's role:

Single Responsibility Principle (SRP): Encourages each class or module to have a single responsibility, ensuring clarity and maintainability.
Open/Closed Principle (OCP): Fosters code that is open for extension but closed for modification, enabling new functionalities without altering existing code.
Liskov Substitution Principle (LSP): Ensures that objects of a superclass can be replaced by objects of its subclasses without affecting the program's functionality.
Interface Segregation Principle (ISP): Promotes smaller, cohesive interfaces rather than large, all-encompassing ones, preventing clients from depending on interfaces they do not use.
Dependency Inversion Principle (DIP): Encourages abstraction and decoupling by depending on abstractions rather than concrete implementations, facilitating flexibility and scalability.

SOLID design principles and their usage are explained in the the context of game development with great details in the book: Learning Game Architecture with Unity, which is available @ Amazon, Amazon India, BPB International, BPB India.

Clean Code and Architecture for Game Development

Niraj Vishwakarma — Sat, 05 Apr 2025 09:34:40 +0000

This post is an excerpt from the book Learning Game Architecture with Unity

Architecture, architecture, architecture — it's everywhere. Be it in buildings, crafts, or games.

But before jumping directly into Game Architecture and why it should be considered for your project, let's first discuss the No-Architecture problem — and why following a no-architecture approach could turn into a nightmare for your project in the long run.

The No-Architecture problem

A No-Architecture issue, in the context of software development, especially game development, refers to a situation where a project lacks a well-defined and structured architectural framework. In simpler terms, it means that the software or game has been developed without a clear plan or design for how its components, systems, and modules should interact and work together.

In summary, a No- Architecture issue indicates a lack of proper planning and structure in game development, leading to disorganization, inefficiency, and a range of challenges that can impede the success of a game project. Addressing this issue often involves implementing a well-thought-out architectural framework to guide development and promote more efficient and maintainable projects.

When a game project lacks a well-defined architectural framework, it often encounters difficulties during the various phases of development, particularly when it comes to bug fixes. Fixing bugs at later stages, such as during feature implementation, testing, or even post-release phases, can prove to be a daunting task. The absence of a clear architectural roadmap makes it harder to trace the origin of bugs, leading to extended debugging periods. This delay can have significant repercussions, both in terms of financial costs and man-hours.

How Game Architecture manages to avoid issues poised by No-Architecture problem

Game architecture plays a crucial role in better project management for game development. game architecture is required for better project management in game development because it brings structure, organization, and efficiency to the development process. It allows for smooth collaboration, scalability, and modularity while promoting code quality and maintainability. By following sound architectural principles, game developers can better manage their projects, meet deadlines, and deliver high-quality games to their players.

Let us elaborate on how game architecture focuses on breaking down the project into logical modules, reusing these modules for efficiency, incorporating software design principles for clean code, and leveraging game design patterns for modular and maintainable code.

So now we can identify the three pillars of game architecture as:

Modular project breakdown
Guided by software design principles
Harnessing game design patterns

Modular project breakdown

Game architecture involves a systematic breakdown of a game project into logical and self-contained modules. Each module typically represents a specific aspect or feature of the game, such as gameplay mechanics, graphics rendering, audio, and user interfaces.

Efficient development: Breaking the project into modules allows different teams or developers to work on distinct parts of the game simultaneously. This parallel development process enhances efficiency and helps meet project deadlines.
Code re-usability: Game architecture encourages the creation of reusable modules. These modules can be employed not only within the current project but also in future projects. This re-usability minimizes redundancy, saves development time, and ensures consistency across different games.

Guided by software design principles

To maintain clean and well-structured code, game architecture draws upon established software design principles. Some popular software design principles are SOLID principles, Don’t Repeat yourself (DRY) principles and Keep it simple and Stupid (KISS) principles. These principles guide the architectural decisions to ensure code quality and maintainability.

Modularity: Modularity is a fundamental software design principle, and game architecture aligns with it. Each module encapsulates a specific functionality or set of features, making it easier to manage and maintain. Changes to one module have minimal impact on the others, reducing the risk of unintended side effects and simplifying project management.
Abstraction: Game architecture utilizes abstraction to hide the complexity of underlying systems. This makes the code more understandable and maintainable. Abstraction enables developers to focus on high-level concepts without getting bogged down in the implementation details.
Separation of concerns: Game architecture enforces a separation of concerns, where each module has a specific, well-defined responsibility. This separation helps developers address specific issues or make improvements without affecting unrelated parts of the game.

Harnessing game design patterns

Game architecture incorporates game design patterns to create more modular and maintainable code. Some popular game design patterns include the Singleton, Observer, Command, and State Machine patterns. We will learn more about these patterns in upcoming chapters. These patterns are solutions to common design challenges in game development, improving the overall structure of the game.

Modular code: Game design patterns emphasize modular design. They provide blueprints for organizing code into manageable components, making it easier to develop, understand, and modify specific functionalities.
Maintainable code: By following established game design patterns, developers create code that is inherently maintainable. This means that as the game evolves and requires updates, developers can make changes with confidence, knowing that the existing architectural structure supports maintainability.

All these points related to Game architecture and their implementation are covered in detail in the book Learning Game Architecture with Unity, which is available @ Amazon, Amazon India, BPB International, BPB India.

In summary, game architecture promotes efficient development by breaking the project into logical modules and encouraging code re-usability. It leverages software design principles to ensure clean, organized code, while integrating game design patterns to create modular and maintainable solutions. This holistic approach is crucial for successful game development, helping developers manage projects effectively and deliver high-quality games.

Learning Game Architecture with Unity – My New Book is Out Now!

Niraj Vishwakarma — Sat, 29 Mar 2025 09:06:31 +0000

I'm excited to share some great news with Unity developers! My new book, "Learning Game Architecture with Unity", is now available at:
[BPB] Online ,
BPB India,
Amazon and
Amazon India.

Why This Book is Essential

Many developers struggle with unstructured learning, jumping from one tutorial to another without truly mastering game architecture. This book provides a structured, step-by-step approach to building scalable, maintainable, and performance-optimized Unity projects.

What’s Inside?

✔ OOP Principles & SOLID Design – Build clean, flexible, and modular game systems.
✔ Game Architecture Patterns – Learn MVC, MVCS, and other proven structures for Unity development.
✔ Game Design Patterns – Understand core design patterns that enhance gameplay mechanics and maintainability.
✔ Project Planning & UML Diagrams – Effectively design and structure complex game projects.
✔ Debugging & Optimization – Master techniques to improve performance, reduce lag, and enhance gameplay flow.
✔ Real-World Implementation – Apply concepts through a sample Unity project that brings everything together.

Who Should Read This?

This book is ideal for beginners looking to build a strong foundation and experienced developers seeking to refine their project architecture. Team leads and senior developers will also find it invaluable for establishing scalable game structures that development teams can follow.

Get Your Copy Today!

Explore this comprehensive guide and take your Unity projects to the next level.

📖 Order Now: BPB Online | BPB India | Amazon

Let’s build better games together! 🎮🔥