DEV Community: Md Maruf Howlader

Create a Tic Tac Toe Game in Unity

Md Maruf Howlader — Wed, 11 Sep 2024 16:49:41 +0000

Introduction to Building a Tic Tac Toe Game in Unity

In this tutorial, you'll learn how to create a simple Tic Tac Toe game in Unity. We’ll guide you through setting up the game’s UI, handling player interactions, and implementing the game logic.

By the end, you'll have a working game where players take turns marking the grid, and the game detects wins or draws. We’ll also cover resetting the game and updating the UI with game results.

This guide is perfect for beginners or those looking to enhance their Unity skills with a fun project. Let’s get started!

Step 1: Project Setup

Create a new Unity 2D project.

Folder Structure:
- Under the Assets folder, create a folder named TicTacToe. Inside this folder, create:
  - Scripts
  - Prefabs
  - Resources
  - Scenes
- Create a new Scene and save it under the Scenes folder.

Resources Folder:
- Inside the Resources folder, add 3 square images: x.png (X icon), o.png (O icon), and b.png (empty image with a white background). Download the images from here and drag them into the Resources folder.
Script Folder:
- Create several scripts by right-clicking in the Scripts folder and selecting Create > C# Script. Name the scripts as follows: Cell.cs, UICellBehaviour.cs, BoardManager.cs, TurnManager.cs, and UIBehaviour.cs. We’ll explain why we need each of these scripts later.

PersistentMonoSingleton.cs: Download here and drop it into the Scripts folder. This class will help us make a class both persistent (accessible globally across scenes) and singleton (only one instance exists in the entire game). This class is not directly related to gameplay but is used to manage global game objects.

Step 2: UI Setup in Unity

Now, let’s plan the visual representation of the Tic Tac Toe game using Unity’s Canvas system. The following steps will guide you through setting up the 3x3 grid and linking the logic to the visual elements.

Create a Canvas:
- Open the newly created scene and switch to 2D mode in the Scene view.
- Right-click in the Hierarchy and select UI -> Canvas.
Create a Grid Panel:
- Right-click on the Canvas and create a new Panel. Rename it Grid.
- Set the Rect Transform to Stretch and add an Aspect Ratio Fitter component. Set:
  - Aspect Mode: Fit in Parent
  - Aspect Ratio: 1

Vertical Layout Group:
- Inside the Grid, create another Panel. Rename it Vertical Layout Group.
- Set its Rect Transform to Stretch.
- Add a Vertical Layout Group component and enable:
  - Spacing: 10
  - Control Child Size (Width and Height)
  - Child Force Expand (Width and Height)

Row Panel:
- Inside the Vertical Layout Group, create another Panel and name it Row.
- Add a Horizontal Layout Group component and enable:
  - Spaceing 10
  - Control Child Size (Width and Height)
  - Child Force Expand (Width and Height)

Cell Button:
- Inside the Row panel, right-click and add a UI -> Image. Rename it Cell Button.
- From Inspector window, click Add-Component, add a Button component to the Cell Button.

Step 3: Prefab Creation and Replication

Create a Prefab:
- Drag the Cell Button from the Hierarchy into your project’s Prefab folder to create a prefab.
Duplicate Buttons:
- In the Row panel, duplicate the Cell Button twice.

Duplicate the Row panel twice to create three rows. You now have a 3x3 grid with 9 buttons.

Naming Cells:
- Rename each button: Cell Button 0, Cell Button 1, ..., Cell Button 8.

Note: In the Scene view, set the camera background to Solid Color and choose the color you want for the board background.

Managing the Cell State with Cell.cs

The Cell.cs script is responsible for managing the state of each individual cell in the Tic Tac Toe game. It stores the cell's current value, controls its interactivity, and communicates changes to other parts of the game via events.

Key Responsibilities of `Cell.cs`:

Track Cell State: It keeps track of whether the cell is blank, marked with X, or marked with O.
Handle Interactivity: It determines whether the cell is clickable based on the current game state.
Trigger Game Events: It raises events when the cell’s value changes or when the game finishes, allowing other game components to respond accordingly.

using System;
using UnityEngine;

namespace com.marufhow.tictactoe.script
{
    [CreateAssetMenu(fileName = "Cell", menuName = "Game/Cell")]
    public class Cell : ScriptableObject
    {
        public int Id;
        public int Value; // 0: blank, 1: X, 2: O
        public bool IsInteractive { get; private set; }
        public event Action<int, int> OnValueChanged;
        public event Action<bool> OnGameFinished;
        public void SetValue(int newValue)
        {
            Value = newValue;
            OnValueChanged?.Invoke(Id, Value);
        }
        public void SetResult(bool isWin)
        {
            OnGameFinished?.Invoke(isWin);
            IsInteractive = false;
        }
        public void Reset()
        {
            IsInteractive = true;
            SetValue(0);
        }
    }
}

Script Breakdown:

Id: A unique identifier for each cell.
Value: Tracks whether the cell is blank, marked with X, or marked with O.
IsInteractive: Controls whether the cell is clickable.
OnValueChanged and OnGameFinished: Events that notify the game when a cell's value changes or when the game finishes.

Key Methods of `Cell.cs`

SetValue(int newValue): Updates the cell's value (X, O, or blank) and triggers the OnValueChanged event to notify listeners.
SetResult(bool isWin): Marks the cell as part of a winning combination or not, disables interactivity, and triggers the OnGameFinished event.
Reset(): Resets the cell's value to blank and makes it interactive again for a new game.

Connecting the UI with UICellBehaviour.cs

The UICellBehaviour.cs script links the cell’s logic to its visual representation in the Unity UI. It handles player input, updates the button's visual state, and reacts to changes in the cell's value during gameplay.

Key Responsibilities of `UICellBehaviour.cs`:

Update Cell Appearance: It ensures the UI reflects the current state of the cell, displaying either X, O, or blank based on the player's action.
Handle Player Interaction: It listens for clicks on the cell button and updates the cell value based on whose turn it is.
Respond to Cell Events: It listens for changes in the cell’s state and updates the UI accordingly, including handling game results (win or loss).

using UnityEngine;
using UnityEngine.UI;

namespace com.marufhow.tictactoe.script
{
    public class UICellBehaviour : MonoBehaviour
    {
        [SerializeField] private Cell cell; 
        [SerializeField] private Button button;
        [SerializeField] private Image image;
        [SerializeField] private Color defaultColor;
        [SerializeField] private Color winColor;
        [SerializeField] private Color failedColor;
        private Sprite xImage;
        private Sprite oImage;
        private Sprite blankImage;
        private void Awake()
        {
            xImage = Resources.Load<Sprite>("x");
            oImage = Resources.Load<Sprite>("o");
            blankImage = Resources.Load<Sprite>("b");
        }
        private void Start()
        {
            button.onClick.AddListener(OnButtonClick);
        }
        private void OnEnable()
        {
            cell.OnValueChanged += OnValueChanged;
            cell.OnGameFinished += OnGameFinished;
        }
        private void OnDisable()
        {
            cell.OnValueChanged -= OnValueChanged;
            cell.OnGameFinished -= OnGameFinished;
        }
        private void OnValueChanged(int cell, int newValue)
        {
            image.sprite = newValue == 1 ? xImage : oImage;

            if (newValue != 0) return; // game restart
            image.sprite = blankImage;
            image.color = defaultColor;
        }
        private void OnGameFinished(bool isGameWin)
        {
            image.color = isGameWin ? winColor : failedColor;
        }
        private void OnButtonClick()
        {
            if(!cell.IsInteractive) return;
            if (cell.Value == 0) // Only change if blank
            {
                bool isXTurn = TurnManager.Instance.GetTurn();
                int newValue = isXTurn ? 1 : 2;
                cell.SetValue(newValue);
            }
        }
    }
}

Key Methods of `UICellBehaviour.cs`

Awake(): Loads X, O, and blank sprites.
Start(): Adds the click listener for the button.
OnEnable() / OnDisable(): Subscribes/unsubscribes from cell state events.
OnValueChanged(): Updates the button's image based on the cell’s value.
OnGameFinished(): Changes the cell color after a win or loss.
OnButtonClick(): Updates the cell's value when clicked.

Assigning ScriptableObjects to the UICellBehaviour

Cell ScriptableObject Instances:
- Create 9 instances of Cell ScriptableObjects (named Cell 0 through Cell 8). Assign unique IDs (0 to 8).

Attach the Script:
- Drag and drop the UICellBehaviour.cs script onto the Cell Button in the Inspector for the first button.
- Assign the serialized fields in UICellBehaviour:
  - Button: The button component itself.
  - Image: The image component of the Cell Button.
  - Colors: Assign the desired colors for default, win, and failed states.
  - Cell: Leave empty for now.
Prefab Overrides:
- Go to the Inspector, click on Override -> Apply All to apply these settings to the prefab. The rest of the prefabs will inherit this configuration automatically.

Assign ScriptableObjects:
- For each UICellBehaviour, assign the corresponding Cell ScriptableObject:
  - Assign Cell 0 to Cell Button 0, Cell 1 to Cell Button 1, and so on until Cell 8.

Managing Turns with TurnManager

The TurnManager script is responsible for alternating between players (X and O) during the game. It ensures that players take turns one after another by switching a boolean variable. This script uses the PersistentMonoSingleton to ensure that only one instance of the TurnManager exists and persists across scenes, if needed.

Key Responsibilities of `TurnManager.cs`:

Handle Player Turns: Alternates the turn between player X and player O.

using com.marufhow.tictactoe.script.utility;
using UnityEngine;

namespace com.marufhow.tictactoe.script
{
    public class TurnManager : PersistentMonoSingleton<TurnManager>
    {
        private bool xUserTurn;

        private void Start()
        {
            xUserTurn = true; // X player starts first
        }

        public bool GetTurn()
        {
            bool turn = xUserTurn;
            xUserTurn = !xUserTurn; // Switch turns between X and O
            return turn;
        }

        protected override void Initialize()
        {
            // Any additional initialization can be placed here
        }
    }
}

Key Components of `TurnManager.cs`:

xUserTurn: A boolean variable that tracks whose turn it is. If true, it's X’s turn; if false, it's O’s turn.
GetTurn(): This method returns the current player’s turn (X or O) and then toggles the turn for the next player.

How to Implement:

Create an empty GameObject in the Scene and name it TurnManager.
Assign the TurnManager.cs script to this GameObject. Since the class inherits from PersistentMonoSingleton, it will automatically become a globally accessible singleton, and only one instance of it will exist throughout the game.

Managing the Tic Tac Toe Game Logic with BoardManager

The BoardManager script handles the overall game logic, including win conditions and resetting the game. It interacts with the Cell ScriptableObjects to manage the game state.

Key Responsibilities of `BoardManager.cs`:

Track Cell States: Manages the state of all cells using a list of Cell ScriptableObjects.
Win Condition Logic: Defines the possible winning combinations (rows, columns, diagonals) and checks if a player has achieved a win.
Game Events: Triggers events when the game ends (either win or draw) and when the board is reset.

using System;
using System.Collections.Generic;
using com.marufhow.tictactoe.script.utility;
using UnityEngine;

namespace com.marufhow.tictactoe.script
{
    public class BoardManager : PersistentMonoSingleton<BoardManager>
    {
        public event Action<int, bool> OnGameFinished;
        public event Action OnReset;

        [SerializeField] private List<Cell> cellsList = new();

        private readonly int[][] winConditions =
        {
            new[] { 0, 1, 2 }, // Row 1
            new[] { 3, 4, 5 }, // Row 2
            new[] { 6, 7, 8 }, // Row 3
            new[] { 0, 3, 6 }, // Column 1
            new[] { 1, 4, 7 }, // Column 2
            new[] { 2, 5, 8 }, // Column 3
            new[] { 0, 4, 8 }, // Diagonal 1
            new[] { 2, 4, 6 }  // Diagonal 2
        };
        private void Start()
        {
            ResetGame(); // game start point
        }
        private void OnEnable()
        {
            foreach (var cell in cellsList) cell.OnValueChanged += CheckWinCondition;
        }
        private void OnDisable()
        {
            foreach (var cell in cellsList) cell.OnValueChanged -= CheckWinCondition;
        }
        private void CheckWinCondition(int cellId, int value)
        {
            foreach (var condition in winConditions)
                if (cellsList[condition[0]].Value == value &&
                    cellsList[condition[1]].Value == value &&
                    cellsList[condition[2]].Value == value &&
                    value != 0)
                {
                    cellsList[condition[0]].SetResult(true);
                    cellsList[condition[1]].SetResult(true);
                    cellsList[condition[2]].SetResult(true);

                    for (var i = 0; i < cellsList.Count; i++)
                        if (i != condition[0] && i != condition[1] && i != condition[2])
                            cellsList[i].SetResult(false);

                    OnGameFinished?.Invoke(value, true);
                    return;
                }
            var allCellFilled = true;
            foreach (var cell in cellsList)
                if (cell.Value == 0)
                {
                    allCellFilled = false;
                    break;
                }
            if (allCellFilled)
            {
                foreach (var cell in cellsList) cell.SetResult(false);
                OnGameFinished?.Invoke(0, false); // Tie
            }
        }
        public void ResetGame()
        {
            foreach (var cell in cellsList) cell.Reset();
            OnReset?.Invoke();
        }
        protected override void Initialize()
        {
        }
    }
}

Key Methods of `BoardManager.cs`

Start(): Initializes the game by calling ResetGame() to set all cells to their default state.
OnEnable() / OnDisable(): Subscribes/unsubscribes from the Cell's OnValueChanged event to monitor cell changes.
CheckWinCondition(): Checks for a winning combination or a tie and triggers the game finished event accordingly.
ResetGame(): Resets all cells and triggers the reset event to restart the game.

How to Implement:

Create an empty GameObject in the Scene and name it BoardManager.

Assign the BoardManager.cs script to this GameObject. Since the class inherits from PersistentMonoSingleton, it will automatically become a globally accessible singleton, and only one instance of it will exist throughout the game.

Managing the User Interface with UIBehaviour

The UIBehaviour script handles the user interface, updates the game status, manages the restart button, and displays game results (win or draw).

Key Responsibilities of `UIBehaviour.cs`:

Display Game Status: Updates the UI to show whether the game is ongoing, won, or ended in a draw.
Restart Game: Manages the restart button, allowing the player to reset the game.
Respond to Game Events: Listens for events from the BoardManager to update the UI when the game finishes or resets.

using com.marufhow.tictactoe.script.utility;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

namespace com.marufhow.tictactoe.script
{
    public class UIBehaviour : MonoBehaviour
    {
        [SerializeField] private TextMeshProUGUI gameStatusText;
        [SerializeField] private Button restartButton;
        [SerializeField] private GameObject containerPanel;
        private void OnEnable()
        {
            BoardManager.Instance.OnGameFinished += HandleGameFinished;
            BoardManager.Instance.OnReset += ResetUI;
        }
        private void OnDisable()
        {
            BoardManager.Instance.OnGameFinished -= HandleGameFinished;
            BoardManager.Instance.OnReset -= ResetUI;
        }
        private void Start()
        {
            restartButton.onClick.AddListener(RestartGame);
        }
        private void HandleGameFinished(int value, bool isWin)
        {
            if (isWin)
            {
                string winner = value == 1 ? "X" : "O";
                gameStatusText.text = $"{winner} Player Wins!";
            }
            else
            {
                gameStatusText.text = "It's a Draw! Try Again.";
            }
            containerPanel.SetActive(true);
        }
        private void ResetUI()
        {
            gameStatusText.text = "";
            containerPanel.SetActive(false);
        }
        private void RestartGame()
        {
            BoardManager.Instance.ResetGame();
        }
    }
}

Key Methods of `UIBehaviour.cs`

OnEnable() / OnDisable(): Subscribes/unsubscribes from the BoardManager's OnGameFinished and OnReset events to update the UI when the game ends or resets.
Start(): Adds a listener to the restart button to reset the game when clicked.
HandleGameFinished(): Updates the game status text and shows the result panel when the game ends.
ResetUI(): Clears the game status and hides the result panel to prepare for a new round.

5. `RestartGame()`: Calls `BoardManager.ResetGame()` to restart the game.

Game UI Setup

Create a Panel:
- Under Canvas, create a new panel named UI Behaviour. Set the Rect Transform to Stretch for both pivot and position.
Attach the UIBehaviour Script:
- Attach the UIBehaviour.cs script to the UI Behaviour panel.
Create Child Components:
- Under UI Behaviour, create a child panel named Container. Set its Rect Transform to Stretch.
- Inside the Container panel, create a TextMeshProUGUI and a Button for displaying the game status and restarting the game.
Assign Serialized Fields:
- In UIBehaviour.cs, assign the following fields in the Inspector:
  - Container: Assign the Container panel.
  - Status Text: Assign the TextMeshProUGUI text.
  - Restart Button: Assign the Button.

This setup will allow you to display the game status and reset the game when needed.

Congratulations! You've successfully created a fully functional Tic Tac Toe game in Unity. You’ve learned how to design the game’s UI, manage cell interactions using ScriptableObjects, implement win conditions with the BoardManager, and update the UI to show the game status.

With this foundation, you can further enhance your game by adding features like sound effects, animations, or even AI for single-player mode. This project demonstrates how to combine game logic and UI elements in Unity, and you’re now ready to apply these skills to more complex games.

You can check out this GitHub repository here.

You can also play the game here.

Serialization in Unity

Md Maruf Howlader — Sun, 08 Sep 2024 16:09:17 +0000

In the dynamic world of game development, managing data efficiently is crucial. One of the most powerful tools for achieving this in Unity is its serialization system. It is an essential component for anyone working in Unity. Serialization in Unity is a powerful yet often overlooked feature that manages how data is saved, loaded, and transferred within a game. In this write-up, I aim to simplify and explain the core concepts of Unity’s serialization system to help you better understand its importance in game development.

SerializeField

Firstly, We use SerializeField with private fields to make them visible in the Unity Inspector. Public fields are automatically serialized, but SerializeField helps keep fields private while still allowing developers to modify values in the Inspector.

[SerializeField] // Makes the private field visible in the Inspector
private int health = 100;

Serializable Custom Class

We commonly use System.Serializable on a class or object to make it visible in the Inspector and prepare it for saving/loading to/from storage or databases using formats like JSON, YAML, or other formats.

[System.Serializable]
public class Weapon
{
    public string name;
    public int damage;
}

public Weapon sword;

void Start()
{
    Debug.Log("Weapon: " + sword.name + ", Damage: " + sword.damage);
}

Network Serialization

When transmitting data over a network, we often need to serialize data using NetworkMessage or UNet to ensure the data can be sent properly.

public class PlayerPositionMessage : MessageBase
{
    public Vector3 position;

    public override void Deserialize(NetworkReader reader)
    {
        position = reader.ReadVector3();
    }

    public override void Serialize(NetworkWriter writer)
    {
        writer.Write(position);
    }
}

But Unity serialization does much more

GameObject Instantiation

When you instantiate a GameObject in Unity, it works through serialization. Unity takes the original prefab or object, serializes its state, and then creates a new instance by deserializing that data, effectively copying the properties and values from the original.

public GameObject prefab;

void Start()
{
    // Instantiate a new object based on the serialized state of the prefab
    GameObject newObject = Instantiate(prefab);
    Debug.Log("Instantiated: " + newObject.name);
}

Prefabs are saved as serialized objects in Unity. This means that all the components and properties of the prefab are stored in a serialized form. When you instantiate a prefab, Unity deserializes that data and creates a new instance with all the same settings and references.

Scene Serialization

Unity scenes are serialized objects. Every object in the scene, including its components, position, and properties, is saved in a serialized format. When you load a scene, Unity deserializes the scene file, reconstructing all objects to their previous states.

public GameObject exampleObject;

void Start()
{
    // Move object and save the state in the scene
    exampleObject.transform.position = new Vector3(0, 10, 0);

    // Serialized position will be restored on reload
    Debug.Log("Object moved, and its position is serialized.");
}

ScriptableObjects

ScriptableObjects are powerful because they can hold serialized data outside of scenes. This means you can store configurations, game data, or even level information in them, and the data persists between play sessions.

[CreateAssetMenu(fileName = "GameSettings", menuName = "Game Settings")]
public class GameSettings : ScriptableObject
{
    public float volume;
    public int difficulty;
}

public GameSettings gameSettings;

void Start()
{
    Debug.Log("Volume: " + gameSettings.volume + ", Difficulty: " + gameSettings.difficulty);
}

Complex Data Structures

Unity's internal data structures, like Renderer settings, use serialization to store configurations between sessions or in assets. Other examples include Materials, Animators, and scene objects, which also rely on serialization to store their data.

[SerializeField]
private Renderer playerRenderer;

void Start()
{
    playerRenderer.material.color = Color.red;
}

Metadata

Each Unity asset (e.g., Prefabs, Materials) has a corresponding .meta file that stores metadata, including file GUIDs that help maintain asset references. Serialization keeps these relationships intact when editing assets.

[CreateAssetMenu(fileName = "NewWeapon", menuName = "Weapon")]
public class WeaponScriptableObject : ScriptableObject
{
    public string weaponName;
    public int powerLevel;
}

Mapping references

Mapping references within Prefabs, ScriptableObjects, or even Presets is part of Unity's serialization system. When you serialize an object, Unity ensures these references are stored and loaded correctly.

Undo Functionality

When you press undo in Unity, it uses serialization to restore the previous state of objects, allowing changes to be reversed.

Let's Learn the Basics of Serialization

What is Serialization?

Serialization is the process of converting an object's state into a format (binary, JSON, YAML, etc.) that can be stored, transmitted, or reconstructed later. It’s key for saving data, sending data over networks, and managing Unity assets. Think of it as organizing data in a linear sequence, one item after another.

Deserialization is the reverse of serialization, converting stored or transmitted data back into a usable object or data structure.

How does it works!

Serialization System is a robust, optimized, and backward-compatible system, written in c++ for better performance.
Through Unity's keynote, I learned that Unity designed a Serialization Backend, which uses a common method called Transfer. This method is responsible for converting basic data types into a well-organized format. A component known as SerializeTraits distributes the requested data to the appropriate Transfer method based on the data type. This system efficiently handles different data types to ensure proper serialization and deserialization, allowing for smooth data saving, loading, and transmission processes in Unity.

Supported Formats

Binary: Efficient and space-saving. Used internally by Unity for asset files.
YAML: More human-readable, often used in scenes and prefabs.
JSON: Commonly used for network communication and saving files due to its simplicity.

JSON Serialization Example

Serialize and deserialize objects using JSON.

[System.Serializable]
public class PlayerData
{
    public string playerName;
    public int score;
}

public PlayerData playerData = new PlayerData();

void Start()
{
    // Serialize to JSON
    string jsonData = JsonUtility.ToJson(playerData);
    Debug.Log("Serialized Data: " + jsonData);

    // Deserialize from JSON
    string jsonString = "{\"playerName\":\"John\",\"score\":100}";
    PlayerData loadedPlayerData = JsonUtility.FromJson<PlayerData>(jsonString);
    Debug.Log("Deserialized Data: " + loadedPlayerData.playerName + ", Score: " + loadedPlayerData.score);
}

Saving and Loading with Unity’s Serialization

Saving and loading game data using Unity’s serialization (via JSON).

[System.Serializable]
public class GameData
{
    public int level;
    public int lives;
}

public GameData data = new GameData();

void Start()
{
    string path = Application.persistentDataPath + "/savefile.json";

    // Serialize to JSON and save
    string json = JsonUtility.ToJson(data);
    File.WriteAllText(path, json);
    Debug.Log("Game saved!");

    // Load and deserialize
    if (File.Exists(path))
    {
        string loadedJson = File.ReadAllText(path);
        GameData loadedData = JsonUtility.FromJson<GameData>(loadedJson);
        Debug.Log("Level: " + loadedData.level + ", Lives: " + loadedData.lives);
    }
}

Key Takeway

Fields must be public or marked with [SerializeField].
Static, const, and readonly fields are not serialized.
Unity supports serialization of primitive types, enums, built-in types, custom structs, and custom classes.
You can also serialize arrays and lists of these types.

// 1. Public field (automatically serialized)
public int publicField = 10;

// 2. Private field with SerializeField (serialized)
[SerializeField]
private float privateField = 3.5f;

// 3. Static field (NOT serialized)
public static int staticField = 5; // Won't be saved

// 4. Const field (NOT serialized)
public const int constField = 100; // Not serialized

// 5. Readonly field (NOT serialized)
public readonly string readOnlyField = "ReadOnly"; // Not serialized

// 6. Primitive data types
public int intField = 25;
public bool boolField = true;

// 7. Enum type (serialized if 32 bits or smaller)
public ExampleEnum enumField = ExampleEnum.Option1;

// 8. Unity built-in types
public Vector3 position = new Vector3(1, 2, 3);
public Color color = Color.red;

// 9. Serializable struct
[Serializable]
public struct CustomStruct
{
    public int value;
    public string name;
}
public CustomStruct customStruct;

// 10. UnityEngine.Object reference
public GameObject objectReference;

// 11. Serializable custom class
[Serializable]
public class CustomClass
{
    public float classValue;
    public string className;
}
public CustomClass customClass;

// 12. Array of serializable types
public int[] intArray = { 1, 2, 3 };

// 13. List of serializable types
public List<string> stringList = new List<string> { "Item1", "Item2" };

// Enum for demonstration
public enum ExampleEnum
{
    Option1,
    Option2
}

Unsupported Types

Unity's built-in serialization system doesn't support certain types, like dictionaries, polymorphic objects, or properties/methods, multilevel types (multidimensional arrays, jagged arrays, dictionaries, and nested container types). Avoid nested, recursive structures where you reference other classes.

Unity doesn’t serialize dictionaries by default.


public Dictionary<string, int> scores = new Dictionary<string, int>();

void Start()
{
    scores.Add("Player1", 100);
    scores.Add("Player2", 200);

    // Dictionary won't be serialized automatically by Unity.
}

Polymorphism Limitation Example
Unity’s built-in serialization doesn’t support polymorphism directly.


[System.Serializable]
public class BaseClass
{
    public string baseProperty = "Base Property";
}

[System.Serializable]
public class DerivedClass : BaseClass
{
    public string derivedProperty = "Derived Property";
}

public BaseClass myObject;

void Start()
{
    myObject = new DerivedClass();
    Debug.Log("Base property: " + myObject.baseProperty);
    // Unity won't serialize derivedProperty automatically.
}

Solutions for Unsupported Types:

The ISerializationCallbackReceiver interface in Unity provides callbacks to handle custom serialization and deserialization for data types that Unity's built-in serializer cannot handle. This interface includes two methods: OnBeforeSerialize() and OnAfterDeserialize(), which allow developers to manually process fields before serialization and after deserialization.


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

[Serializable]
public class SerializableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, ISerializationCallbackReceiver
{
    [SerializeField] private List<TKey> keys = new List<TKey>();
    [SerializeField] private List<TValue> values = new List<TValue>();

    public void OnBeforeSerialize()
    {
        keys.Clear();
        values.Clear();

        foreach (KeyValuePair<TKey, TValue> pair in this)
        {
            keys.Add(pair.Key);
            values.Add(pair.Value);
        }
    }
    public void OnAfterDeserialize()
    {
        this.Clear();

        for (int i = 0; i < keys.Count; i++)
        {
            this[keys[i]] = values[i];
        }
    }

}


using UnityEngine;
public class SerializationCallbackScript : MonoBehaviour
{
    public SerializableDictionary<int, string> SerializableDictionary;
    private void Awake()
    {
        SerializableDictionary.Add(1, "One");
        SerializableDictionary.Add(2, "Two");
        SerializableDictionary.Add(3, "Three");
    }
    public void Start()
    {
        string jsonData = JsonUtility.ToJson(SerializableDictionary);
        Debug.Log("Serialized Data: " + jsonData);
    }
}

Thank you for reading this blog, I’ve shared key insights into Unity’s serialization system to help you better manage data and assets in your projects. I hope it provides a clearer understanding and benefits your development process.

If anything wasn’t clear or you have suggestions for improvement, feel free to leave a comment—I’m happy to respond promptly and discuss how we can make things even better!

DEV Community: Md Maruf Howlader

Create a Tic Tac Toe Game in Unity

Introduction to Building a Tic Tac Toe Game in Unity

Step 1: Project Setup

Step 2: UI Setup in Unity

Step 3: Prefab Creation and Replication

Managing the Cell State with Cell.cs

Key Responsibilities of Cell.cs:

Key Methods of Cell.cs

Connecting the UI with UICellBehaviour.cs

Key Responsibilities of UICellBehaviour.cs:

Key Methods of UICellBehaviour.cs

Assigning ScriptableObjects to the UICellBehaviour

Managing Turns with TurnManager

Key Responsibilities of TurnManager.cs:

Key Components of TurnManager.cs:

How to Implement:

Managing the Tic Tac Toe Game Logic with BoardManager

Key Responsibilities of BoardManager.cs:

Key Methods of BoardManager.cs

How to Implement:

Assign the BoardManager.cs script to this GameObject. Since the class inherits from PersistentMonoSingleton, it will automatically become a globally accessible singleton, and only one instance of it will exist throughout the game.

Managing the User Interface with UIBehaviour

Key Responsibilities of UIBehaviour.cs:

Key Methods of UIBehaviour.cs

5. RestartGame(): Calls BoardManager.ResetGame() to restart the game.

Game UI Setup

Serialization in Unity

SerializeField

Serializable Custom Class

Network Serialization

But Unity serialization does much more

GameObject Instantiation

Scene Serialization

ScriptableObjects

Complex Data Structures

Metadata

Mapping references

Undo Functionality

Let's Learn the Basics of Serialization

What is Serialization?

How does it works!

Supported Formats

JSON Serialization Example

Saving and Loading with Unity’s Serialization

Key Takeway

Unsupported Types

Solutions for Unsupported Types:

Key Responsibilities of `Cell.cs`:

Key Methods of `Cell.cs`

Key Responsibilities of `UICellBehaviour.cs`:

Key Methods of `UICellBehaviour.cs`

Key Responsibilities of `TurnManager.cs`:

Key Components of `TurnManager.cs`:

Key Responsibilities of `BoardManager.cs`:

Key Methods of `BoardManager.cs`

Key Responsibilities of `UIBehaviour.cs`:

Key Methods of `UIBehaviour.cs`

5. `RestartGame()`: Calls `BoardManager.ResetGame()` to restart the game.