That repetition doesn’t just waste time – it slows down your development and creates maintenance headaches across projects.

This guide walks you through a set of reusable, modular Unity packages you can drop into any project to speed up development. You’ll build them once as packages and install them via Git wherever you need them, instead of reimplementing the same systems every time.

The article covers four core packages:

1. com.core.initializer – Finds and initializes your game controllers at runtime (MVC-style) so startup and dependencies centralized.

2. com.core.data – Handles local (and optionally cloud) save data using MemoryPack binary serialization and a provider abstraction so you can switch or extend storage backends.

3. com.core.ui – Manages popups and full-screen UIs in a consistent way so you can show dialogs, panels, and screens without duplicating logic.

4. com.core.dotween – Wraps the DoTween tween engine as a Unity package so com.core.ui (and other packages) can reference it for animations.

In this tutorial, we’ll build all four packages step by step. The Initializer, Data, UI, and DoTween packages are all documented so you can easily follow along. All packages are also upload to github which you can find the links at the end.

Table of Contents

• What You Will Learn

• Prerequisites

• Set Up Your Development Project

• Package 1: The Initializer Package

• Package 2: The Data Package

• Package 3: The DoTween Package

• Package 4: The UI Package

• Summary

What You Will Learn

• How to create a Unity package with the Package Manager

• How to set up the package structure

• How to built a centralized initialization flow for your packages

• How to use UniTask for async initialization on Unity's main thread

• How the Data package uses IDataProvider and MemoryPack for local save/load

• How the UI package uses popups (stack) and screens (single active) with DoTween animations

Prerequisites

Before you start, make sure you have:

• Unity installed (any Long Term Support version compatible with the packages. The referenced packages target Unity 6000.3)

• Git installed

• Jetbrains Rider or Visual Studio Community installed

• Know how to use Unity game engine

• Know C# and async/await structures

You will use the Unity Package Manager to create packages, then upload and install them via Git in other projects.

Set Up Your Development Project

Create a new Unity project if you don’t already have one. We’ll use it as a playground to build and test your packages. This project (and not the packages themselves) is your development environment.

Package 1: The Initializer

The first package is com.core.initializer. It finds all your controllers, runs their async initialization before the first scene loads, and lets the rest of the game access them via a single handler.

What com.core.initializer Does

• Early initialization: Runs at RuntimeInitializeLoadType.BeforeSceneLoad, so all controllers exist and are initialized before the first scene loads.

• Central access: Stores each controller by its type and exposes them through a type-safe getter.

• Completion signaling: Exposes a static event (ControllersInitialized) and a UniTaskCompletionSource (InitializationCompleted) so you can run code only after all controllers have finished initializing.

Create the Initializer Package

To start, open Window → Package Manager (under Package Management). Then click the + button and choose Create package.

Name the package com.core.initializer (or your preferred name).

Unity creates the essential package files for you.

You can edit package.json and the assembly definition (asmdef) names to match your naming. The full set of changes is not listed here. The final package is available on GitHub (linked at the end).

Add the UniTask Dependency

Unity runs on the main thread, and C# Tasks can be problematic in that context. They don’t know about the Unity Editor's play state and keep running after exiting play mode for example. So you’ll need to handle these cases manually. For these reasons, this package uses UniTask instead of C# Tasks for async operations.

Git-based dependencies are supported at the project level but not at the package level. Add UniTask via OpenUPM by following the manual installation steps.

Add UniTask as a dependency in package.json of initializer package:

"dependencies": {
  "com.cysharp.unitask": "2.5.10"
}

Also reference UniTask in the asmdef file.

You’ll need to follow this dependency flow for the rest of the packages you create.

Implement the Package Structure

The initializer uses an MVC-like architecture. Controllers handle both initialization and game logic. You could later split initialization into services and keep business logic in controllers (for example, an MVCS-style setup). This tutorial keeps things simple and uses only controllers.

Target layout:

• Runtime/Interface/ – IController

• Runtime/Helper/ – Creator (reflection-based instance creation)

• Runtime/ – ControllerHandler (orchestrates initialization)

All controllers implement the IController interface. The Initialize method returns a UniTask so initialization can be async on the main thread.

using Cysharp.Threading.Tasks;

namespace com.core.initializer
{
    public interface IController
    {
        bool IsInitialized { get; }

        UniTask Initialize();
    }
}

Create the Creator Helper

You’ll need to find all types that implement IController, create instances of them at runtime, and also find MonoBehaviours that implement IController (since those cannot be created via reflection). The Creator class does both.

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

namespace com.core.initializer
{
    public static class Creator
    {
        /// <summary>
        /// Creates instances of every type which inherits from T interface.
        /// </summary>
        public static IEnumerable<T> CreateInstancesOfType<T>(params Type[] exceptTypes)
        {
            var interfaceType = typeof(T);

            var result = AppDomain.CurrentDomain.GetAssemblies().SelectMany(x => x.GetTypes()).Where
                (
                 x => interfaceType.IsAssignableFrom(x) &&
                      !x.IsInterface                    &&
                      !x.IsAbstract                     &&
                      exceptTypes.All(type => !x.IsSubclassOf(type) && x != type)
                ).Select(Activator.CreateInstance);

            return result.Cast<T>();
        }

        public static IEnumerable<T> GetMonoControllers<T>() => UnityEngine.Object.FindObjectsByType<MonoBehaviour>(FindObjectsInactive.Include, FindObjectsSortMode.None).OfType<T>();
    }
}

Using reflection at runtime has some overhead. You can optimize this later with baking the reflection in editor and using it at runtime. For MonoBehaviours, FindObjectsByType is used here for simplicity. In a larger project, you might use a dependency injection solution such as VContainer or Reflex.

Implement the ControllerHandler

The ControllerHandler uses Creator to gather all IController instances (both reflection-created and MonoBehaviours), initializes them in order, and exposes an event and a UniTaskCompletionSource so the rest of the game can wait for startup to finish.

using System;
using System.Collections.Generic;
using System.Linq;
using Cysharp.Threading.Tasks;
using UnityEngine;

namespace com.core.initializer
{
    public class ControllerHandler
    {
        public static readonly UniTaskCompletionSource InitializationCompleted = new();

        public static event Action ControllersInitialized;

        private static Dictionary<Type, IController> _controllers = new();

        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
        public static async void Initialize()
        {
            var controllers = Creator.CreateInstancesOfType<IController>(typeof(MonoBehaviour)).ToList();
            controllers.AddRange(Creator.GetMonoControllers<IController>());

            Debug.Log("Initializing controller");

            foreach (var controller in controllers)
            {
                Debug.Log($"<color=yellow>Initializing {controller.GetType().Name}</color>");
                await controller.Initialize();
                _controllers.Add(controller.GetType(), controller);
                Debug.Log($"<color=green>Initialized {controller.GetType().Name}</color>");
            }

            Debug.Log("<color=green>All controllers are initialized</color>");
            ControllersInitialized?.Invoke();
            InitializationCompleted?.TrySetResult();
        }

        public static T GetController<T>() where T : class, IController => _controllers[typeof(T)] as T;
    }
}

How to Test the Initializer

1. Create a class that implements IController (or a MonoBehaviour that implements it).

2. Implement Initialize() with your setup logic (you can use await and UniTask).

3. After initialization, access the controller with:
   var myController = ControllerHandler.GetController<MyController>();

You can also subscribe to ControllerHandler.ControllersInitialized or await ControllerHandler.InitializationCompleted.Task to run code after all controllers are ready.

There are some limitations here. First, it can be hard to handle dependencies between different controllers. Second, it’s easy to run into circular dependencies.

When you check the GitHub repo, a DI framework may already be implemented to address these limitations. Make sure to open an issue if you want this feature.

Package 2: The Data Package

com.core.data handles local saving with a binary serializer. The package uses MemoryPack for fast, binary serialization and defines an IDataProvider interface so you can plug in different providers (local, cloud, or hybrid).

Package dependency: com.cysharp.memorypack (version 1.10.0). Add it to your project via OpenUPM and add it to package.json and the asmdef for com.core.data.

Create a new package and name it com.core.data. Use a structure such as:

• Runtime/Interface/ – IDataProvider

• Runtime/Providers/ – LocalDataProvider

• Runtime/ – optional sample DataController (in your game assembly) that implements IController and uses an IDataProvider

All data providers use the IDataProvider interface.

using Cysharp.Threading.Tasks;

namespace com.core.data
{
    public interface IDataProvider
    {
        bool     IsInitialized { get; }
        void     Save<T>(string key, T data);
        T        Load<T>(string key, T defaultValue = default);
        bool     HasKey(string  key);
        string[] GetKeys();
        UniTask  Delete(string key);
        UniTask  DeleteAll();
    }
}

You will use UniTask in the data package as well. Add com.cysharp.unitask to package.json since both IController and IDataProvider uses it.

Here’s the DataController:

using System;
using System.Collections.Generic;
using System.Text;
using com.core.data;
using com.core.initializer;
using Cysharp.Threading.Tasks;
using UnityEngine;

namespace com.core.data
{
    public class DataController : IController
    {
        private const string PLAYER_VERSION_KEY = "player-version-key";

        private IDataProvider _provider;

        public bool IsInitialized { get; private set; }

        public UniTask Initialize()
        {
            _provider = new LocalDataProvider();
            SaveUserVersion();
            IsInitialized = true;
            return UniTask.CompletedTask;
        }

        private void SaveUserVersion()
        {
            var versionHistory = Load(PLAYER_VERSION_KEY, new List<string>());
            var sb             = new StringBuilder();
            versionHistory.ForEach(vh => sb.Append(vh + Environment.NewLine));
            Debug.Log($"[DataController] Player version history: {sb}");

            if (!versionHistory.Contains(Application.version))
            {
                Debug.Log($"[DataController] Player's current version: {Application.version}");
                versionHistory.Add(Application.version);
                Save(PLAYER_VERSION_KEY, versionHistory);
            }
        }

        public void Save<T>(string key, T data) => _provider.Save(key, data);

        public T Load<T>(string key, T defaultValue = default) => _provider.Load(key, defaultValue);

        public bool         HasKey(string key)  => _provider.HasKey(key);
        public string[]     GetKeys()           => _provider.GetKeys();
        public UniTask      Delete(string key)  => _provider.Delete(key);
        public UniTask      DeleteAll()         => _provider.DeleteAll();
        public List<string> GetVersionHistory() => Load(PLAYER_VERSION_KEY, new List<string>());
    }
}

The controller delegates all logic to LocalDataProvider, which uses MemoryPack to serialize and write bytes to a "Data" folder under Application.persistentDataPath. The controller also keeps the user's app version history, which is useful for upgrade prompts or blocking old versions.

Here’s the full implementation:

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Cysharp.Threading.Tasks;
using MemoryPack;
using UnityEngine;

namespace com.core.data
{
    public class LocalDataProvider : IDataProvider
    {
        private const    string StorageFolderName = "Data";
        private readonly string _storagePath;

        private static readonly UTF8Encoding KeyEncoding = new(false);

        public bool IsInitialized => true;

        public LocalDataProvider()
        {
            _storagePath = Path.Combine(Application.persistentDataPath, StorageFolderName);
            EnsureStorageDirectoryExists();
        }

        public void Save<T>(string key, T data)
        {
            if (string.IsNullOrEmpty(key)) { Debug.LogWarning("[LocalDataProvider] Save called with null or empty key."); return; }
            if (data == null) { Debug.LogWarning("[LocalDataProvider] Save called with null data."); Delete(key).Forget(); return; }
            try
            {
                byte[] bin = MemoryPackSerializer.Serialize(data);
                WriteBytes(key, bin);
            }
            catch (Exception ex) { Debug.LogError($"[LocalDataProvider] Save failed for key '{key}': {ex.Message}"); throw; }
        }

        public T Load<T>(string key, T defaultValue = default)
        {
            if (string.IsNullOrEmpty(key)) { Debug.LogWarning("[LocalDataProvider] Load called with null or empty key."); return defaultValue; }
            if (!ReadBytes(key, out byte[] bin)) return defaultValue;
            try { return MemoryPackSerializer.Deserialize<T>(bin) ?? defaultValue; }
            catch (Exception ex) { Debug.LogError($"[LocalDataProvider] Load failed for key '{key}': {ex.Message}"); return defaultValue; }
        }

        public bool HasKey(string key) => !string.IsNullOrEmpty(key) && File.Exists(GetFilePath(key));

        public UniTask Delete(string key)
        {
            if (string.IsNullOrEmpty(key)) return UniTask.CompletedTask;
            try { var filePath = GetFilePath(key); if (File.Exists(filePath)) File.Delete(filePath); }
            catch (Exception ex) { Debug.LogError($"[LocalDataProvider] Delete failed for key '{key}': {ex.Message}"); }
            return UniTask.CompletedTask;
        }

        public UniTask DeleteAll()
        {
            try
            {
                if (!Directory.Exists(_storagePath)) return UniTask.CompletedTask;
                foreach (string file in Directory.GetFiles(_storagePath))
                {
                    try { File.Delete(file); }
                    catch (Exception ex) { Debug.LogWarning($"[LocalDataProvider] Could not delete file '{file}': {ex.Message}"); }
                }
            }
            catch (Exception ex) { Debug.LogError($"[LocalDataProvider] DeleteAll failed: {ex.Message}"); }
            return UniTask.CompletedTask;
        }

        public string[] GetKeys()
        {
            if (!Directory.Exists(_storagePath)) return Array.Empty<string>();
            var keys = new List<string>();
            foreach (string file in Directory.GetFiles(_storagePath))
            {
                try { string key = DecodeKeyFromFileName(Path.GetFileName(file)); if (key != null) keys.Add(key); }
                catch { Debug.LogWarning($"[LocalDataProvider] Could not read file '{file}'."); }
            }
            return keys.ToArray();
        }

        private void EnsureStorageDirectoryExists() { if (!Directory.Exists(_storagePath)) Directory.CreateDirectory(_storagePath); }
        private void WriteBytes(string key, byte[] bin) { EnsureStorageDirectoryExists(); File.WriteAllBytes(GetFilePath(key), bin); }
        private bool ReadBytes(string key, out byte[] bin) { string filePath = GetFilePath(key); if (!File.Exists(filePath)) { bin = null; return false; } bin = File.ReadAllBytes(filePath); return true; }
        private string GetFilePath(string key) => Path.Combine(_storagePath, EncodeKeyToFileName(key));
        private static string EncodeKeyToFileName(string key) { byte[] bytes = KeyEncoding.GetBytes(key); string base64 = Convert.ToBase64String(bytes); return base64.Replace('+', '-').Replace('/', '_'); }
        private static string DecodeKeyFromFileName(string fileName) { try { string base64 = fileName.Replace('-', '+').Replace('_', '/'); return KeyEncoding.GetString(Convert.FromBase64String(base64)); } catch { return null; } }
    }
}

You can implement another IDataProvider (for example JSON via Newtonsoft or PlayerPrefs) and swap it in your DataController.

In production, you might use a local and a cloud provider and sync data based on the player's online status. The com.core.data GitHub repo may be updated with cloud saving and syncing. You can open an issue if you need that feature.

Package 3: com.core.dotween

com.core.dotween is a Unity package wrapper around DOTween (Demigiant). DoTween is a widely used, production-ready tween engine. The UI package uses it for popup show/hide animations.

DOTween is not available on OpenUPM, so you’ll typically need to download it from the Unity Asset Store and import it into your project (for example, under Assets/Plugins).

Then you’ll run the DOTween setup window(it should pop automatically after importing) and click Create ASMDEF so assembly definition files are generated and you can reference them from other packages.

Next, create a new package (for example, com.core.dotween) and move the Demigiant folder from Assets/Plugins into the package folder so that com.core.ui (or any other package) can depend on com.core.dotween via Package Manager or Git.

After that, reference com.core.dotween in com.core.ui's asmdef(You will create the UI package right after this) so you can use DG.Tweening namespace in BasePopup and other UI scripts.

com.core.dotween has no external dependencies – it only wraps the DOTween asset.

Package 4: The UI Package

com.core.ui centralizes how you show popups and full-screen UIs. It contains:

• Popups – Modal or non-modal dialogs (confirm/cancel, alerts, forms) with a consistent API so you don’t duplicate panel logic in every screen. Popups are stacked – the top one is closed first.

• Screens – Full-screen panels (for example, loading, main menu). Only one screen is active at a time, and switching a screen hides the current one and shows the new one.

Create a new package named com.core.ui with a structure such as:

• Runtime/Interface/ – IUI

• Runtime/UIs/ – BasePopup, BaseScreen

• Runtime/ – UIController, UIParent

• Runtime/Resources/UIPrefabs/ – UIParent prefab, and subfolders Popups and Screens

Add com.core.dotween, com.core.initializer, and com.cysharp.unitask as dependencies in package.json and asmdef.

Popups work like a stack: each popup is shown on top of the previous one and closed from top to bottom. Screens are single-active: only one screen is visible at a time. UIController hides the current one when you show another. UIController is the single point of contact for both screens and popups and handles stacking, caching, and background placement.

IUI Interface

Both BasePopup and BaseScreen implement IUI:

using System;
using Cysharp.Threading.Tasks;

namespace com.core.ui
{
    public interface IUI
    {
        event Action<IUI> Showed;
        event Action<IUI> Hidden;

        UniTask ShowAsync();
        UniTask HideAsync();
    }
}

IUI is a very basic interface with 2 async Show/Hide methods and 2 events to be fired upon completion of those methods.

BasePopup

BasePopup uses DoTween to animate scale on show/hide and exposes events and overridable animation methods:

using System;
using Cysharp.Threading.Tasks;
using DG.Tweening;
using UnityEngine;

namespace com.core.ui
{
    public abstract class BasePopup : MonoBehaviour, IUI
    {
        public event Action<IUI> StartedShowing;
        public event Action<IUI> Showed;
        public event Action<IUI> Hidden;

        [SerializeField] private float   openingTime  = 0.35f;
        [SerializeField] private float   closingTime  = 0.25f;
        [SerializeField] private Vector3 initialScale = new(0.75f, 0.75f, 0.75f);
        [SerializeField] private Ease   openingEase  = Ease.OutBack;
        [SerializeField] private Ease   closingEase  = Ease.InBack;

        protected virtual Tweener PlayShowAnimation(Action completedCallback) => transform.DOScale(Vector3.one, openingTime).SetEase(openingEase).SetUpdate(true).OnComplete(() => completedCallback?.Invoke());
        protected virtual Tweener PlayHideAnimation(Action completedCallback) => transform.DOScale(initialScale, closingTime).SetEase(closingEase).SetUpdate(true).OnComplete(() => completedCallback?.Invoke());

        public UniTask ShowAsync()
        {
            StartedShowing?.Invoke(this);
            transform.SetAsLastSibling();
            var utcs = new UniTaskCompletionSource();
            transform.localScale = initialScale;
            gameObject.SetActive(true);

            PlayShowAnimation(() => OnAnimationShowed(utcs));
            return utcs.Task;
        }

        public void Show() => ShowAsync().Forget();

        public UniTask HideAsync()
        {
            var utcs = new UniTaskCompletionSource();
            PlayHideAnimation(() => OnAnimationCompleted(utcs));
            return utcs.Task;
        }

        private void OnAnimationShowed(UniTaskCompletionSource utcs)
        {
            Showed?.Invoke(this);
            utcs.TrySetResult();
        }

        private void OnAnimationCompleted(UniTaskCompletionSource utcs)
        {
            transform.SetAsFirstSibling();
            gameObject.SetActive(false);
            Hidden?.Invoke(this);
            utcs.TrySetResult();
        }

        public void Hide() => HideAsync().Forget();
    }
}

You can see that DoTween is the core component in this class and a lot of parameters are configurable like opening/closing times and easings. Notice how DoTween completion callbacks are utilized to fire Showed and Hidden events.

Another important thing here is the usage of SetUpdate(true) for animations. This makes animations to ignore timescale. I found that most of the time it's best to ignore the timescale for animations but if you don't want this then feel free to change it.

BaseScreen

BaseScreen only enables/disables the GameObject and raises events. There’s no animation:

using System;
using Cysharp.Threading.Tasks;
using UnityEngine;

namespace com.core.ui
{
    public abstract class BaseScreen : MonoBehaviour, IUI
    {
        public event Action<IUI> Showed;
        public event Action<IUI> Hidden;

        public virtual UniTask ShowAsync()
        {
            gameObject.SetActive(true);
            Showed?.Invoke(this);
            return UniTask.CompletedTask;
        }

        public UniTask HideAsync()
        {
            gameObject.SetActive(false);
            Hidden?.Invoke(this);
            return UniTask.CompletedTask;
        }
    }
}

You will notice that BaseScreen doesn't need UniTask since it is not performing any async operations but it is still beneficial to have this since it doesn't cause any overheads and if we ever need an animation for any of our screens like popups, we have it ready.

UIController

UIController implements IController, instantiates UIParent from Resources, and provides APIs to push/pop popups and show/hide screens. It caches popup and screen instances by type and loads prefabs from Resources:

• UIParent: Resources/UIPrefabs/UIParent

• Popups: Resources/UIPrefabs/Popups/<TypeName>.prefab

• Screens: Resources/UIPrefabs/Screens/<TypeName>.prefab

using System;
using System.Collections.Generic;
using com.core.initializer;
using Cysharp.Threading.Tasks;
using UnityEngine;
using Object = UnityEngine.Object;

namespace com.core.ui
{
    public class UIController : IController
    {
        private const string UI_PARENT_PATH    = "UIPrefabs/UIParent";
        private const string POPUPS_RESOURCES  = "UIPrefabs/Popups";
        private const string SCREENS_RESOURCES = "UIPrefabs/Screens";

        private readonly Stack<BasePopup>             _popupStack  = new();
        private readonly Dictionary<Type, BasePopup>  _popupCache  = new();
        private readonly Dictionary<Type, BaseScreen> _ScreenCache = new();

        private BaseScreen _currentScreen;
        private UIParent   _uiParent;

        public bool IsInitialized { get; private set; }

        public UniTask Initialize()
        {
            var uiParentPrefab = Resources.Load<UIParent>(UI_PARENT_PATH);
            if (uiParentPrefab == null)
            {
                Debug.LogError($"[UIController] UIParent prefab not found at {UI_PARENT_PATH}. Ensure it exists in a Resources folder.");
                return UniTask.CompletedTask;
            }

            _uiParent      = Object.Instantiate(uiParentPrefab);
            _uiParent.name = "UIParent";

            Object.DontDestroyOnLoad(_uiParent.gameObject);

            IsInitialized = true;
            return UniTask.CompletedTask;
        }

        public async UniTask<TPopup> PushPopupAsync<TPopup>() where TPopup : BasePopup
        {
            var popup = GetOrCreatePopup<TPopup>();
            _popupStack.Push(popup);
            var popupTask = popup.ShowAsync();
            UpdateBackgroundForTopPopup();
            await popupTask;
            return popup;
        }

        public void PushPopup<TPopup>() where TPopup : BasePopup => PushPopupAsync<TPopup>().Forget();

        public async UniTask PopPopupAsync()
        {
            if (_popupStack.Count == 0)
            {
                Debug.LogWarning("[UIController] PopPopup called but popup stack is empty.");
                return;
            }

            var top = _popupStack.Pop();
            await top.HideAsync();
            UpdateBackgroundForTopPopup();
        }

        public void PopPopup() => PopPopupAsync().Forget();

        public BasePopup PeekPopup() => _popupStack.Count > 0 ? _popupStack.Peek() : null;

        public async UniTask<TScreen> ShowScreenAsync<TScreen>() where TScreen : BaseScreen
        {
            var screen = GetOrCreateScreen<TScreen>();

            if (_currentScreen == screen && screen.gameObject.activeSelf) return screen;
            if (_currentScreen != null   && _currentScreen != screen && _currentScreen.gameObject.activeSelf) await _currentScreen.HideAsync();

            _currentScreen = screen;
            await screen.ShowAsync();
            return screen;
        }

        public async UniTask HideScreenAsync<TScreen>() where TScreen : BaseScreen
        {
            var type = typeof(TScreen);
            if (!_ScreenCache.TryGetValue(type, out var screen))
            {
                Debug.LogWarning($"[UIController] HideScreenAsync<{type.Name}> called but Screen was never shown (not in cache).");
                return;
            }

            await screen.HideAsync();

            if (_currentScreen == screen) _currentScreen = null;
        }

        public void ShowScreen<TScreen>() where TScreen : BaseScreen => ShowScreenAsync<TScreen>().Forget();
        public void HideScreen<TScreen>() where TScreen : BaseScreen => HideScreenAsync<TScreen>().Forget();

        private TPopup GetOrCreatePopup<TPopup>() where TPopup : BasePopup
        {
            var type = typeof(TPopup);
            if (_popupCache.TryGetValue(type, out var cached) && cached != null) return (TPopup)cached;

            var prefab = LoadPopupPrefab<TPopup>();
            if (prefab == null)
            {
                Debug.LogError($"[UIController] Popup prefab for {type.Name} not found at {POPUPS_RESOURCES}/{type.Name}. Ensure the prefab exists in a Resources folder.");
                return null;
            }

            var instance = UnityEngine.Object.Instantiate(prefab, _uiParent.PopupParent);
            instance.gameObject.SetActive(false);

            var popup = instance.GetComponent<TPopup>();
            _popupCache[type] = popup;

            return popup;
        }

        private TScreen GetOrCreateScreen<TScreen>() where TScreen : BaseScreen
        {
            var type = typeof(TScreen);
            if (_ScreenCache.TryGetValue(type, out var cached) && cached != null) return (TScreen)cached;

            var prefab = LoadScreenPrefab<TScreen>();
            if (prefab == null)
            {
                Debug.LogError($"[UIController] Screen prefab for {type.Name} not found at {SCREENS_RESOURCES}/{type.Name}. Ensure the prefab exists in a Resources folder.");
                return null;
            }

            var instance = UnityEngine.Object.Instantiate(prefab, _uiParent.ScreenParent);
            instance.gameObject.SetActive(false);

            var screen = instance.GetComponent<TScreen>();
            _ScreenCache[type] = screen;

            return screen;
        }

        private TPopup  LoadPopupPrefab<TPopup>() where TPopup : BasePopup     => LoadViewPrefab<TPopup>(POPUPS_RESOURCES);
        private TScreen LoadScreenPrefab<TScreen>() where TScreen : BaseScreen => LoadViewPrefab<TScreen>(SCREENS_RESOURCES);

        private static T LoadViewPrefab<T>(string resourcesPath) where T : MonoBehaviour
        {
            var type = typeof(T);
            var path = $"{resourcesPath}/{type.Name}";
            var go   = Resources.Load<GameObject>(path);
            return go != null ? go.GetComponent<T>() : null;
        }

        private void UpdateBackgroundForTopPopup()
        {
            var backgroundGO = _uiParent.BackgroundGO;
            if (backgroundGO == null) return;

            if (_popupStack.Count > 0)
            {
                var topPopup = _popupStack.Peek();
                if (topPopup != null && topPopup.gameObject.activeSelf)
                {
                    // Position background one step behind the top popup
                    var topPopupIndex = topPopup.transform.GetSiblingIndex();
                    backgroundGO.SetActive(true);
                    backgroundGO.transform.SetSiblingIndex(Mathf.Max(0, topPopupIndex - 1));
                }
                else
                {
                    // Top popup is inactive, hide background
                    backgroundGO.SetActive(false);
                }
            }
            else
            {
                // No popups in stack, hide background
                backgroundGO.SetActive(false);
            }
        }
    }
}

Usage:

var ui = ControllerHandler.GetController<UIController>();
await ui.PushPopupAsync<MyPopup>();
await ui.PopPopupAsync();
await ui.ShowScreenAsync<MainMenuScreen>();
await ui.HideScreenAsync<LoadingScreen>();

UIController also updates the background GameObject so it indexes behind the top popup.

It uses GetOrCreatePopup<TPopup>() / GetOrCreateScreen<TScreen>() to load and cache prefabs from Resources/UIPrefabs/Popups/<TypeName> and Resources/UIPrefabs/Screens/<TypeName>, pushes popups onto a stack, and shows/hides screens with async methods.

UIParent is a MonoBehaviour that holds references to ScreenParent, PopupParent, and BackgroundGO:

using UnityEngine;

namespace com.core.ui
{
    public class UIParent : MonoBehaviour
    {
        [SerializeField] private Transform  screensParent;
        [SerializeField] private Transform  popupsParent;
        [SerializeField] private GameObject backgroundGO;

        public Transform  ScreenParent => screensParent;
        public Transform  PopupParent  => popupsParent;
        public GameObject BackgroundGO => backgroundGO;
    }
}

UIParent prefab has a canvas and UIParent script attached:

There are a couple limitations here as well. First, popups and screens must live under Resources/UIPrefabs/Popups and Resources/UIPrefabs/Screens. Second, prefab name must match the script/type name (for example, TestPopup prefab name for a script named TestPopup).

Summary

In this article, you set up a Unity project and walked through creating four reusable packages:

• com.core.initializer – You created the package, added UniTask, defined IController, used the Creator helper to find and create controllers (including MonoBehaviours), and implemented ControllerHandler to run initialization at BeforeSceneLoad and expose controllers via GetController<T>().

• com.core.data – You use IDataProvider and LocalDataProvider with MemoryPack for binary local save/load, and the DataController that implements IController and tracks version history.

• com.core.dotween – You wrap the DoTween asset as a package so other packages (like com.core.ui) can reference it for animations.

• com.core.ui – You created a modular UI package that you can use in your games to handle popups and full size screens. You can also extend this to add other UI types in the future.

Building these as separate packages keeps your code modular and speeds up development across projects. You can install each package via Git into any Unity project.

Example manifest.json file to implement these packages:

{
  "dependencies"    : {
	"com.core.data"       : "https://github.com/TalhaCagatay/com.core.data.git#v0.1.0",
	"com.core.initializer": "https://github.com/TalhaCagatay/com.core.initializer.git#v0.1.0",
	"com.core.dotween"    : "https://github.com/TalhaCagatay/com.core.dotween.git#v0.1.0",
	"com.core.ui"         : "https://github.com/TalhaCagatay/com.core.ui.git#v0.1.0"
  },
  "scopedRegistries": [
	{
	  "name"  : "package.openupm.com",
	  "url"   : "https://package.openupm.com",
	  "scopes": [
		"com.cysharp.unitask",
		"com.cysharp.memorypack"
	  ]
	}
  ]
}

Resources:

• com.core.initializer on GitHub

• com.core.data on GitHub

• com.core.dotween on Github

• com.core.ui on Github

• Example game that I developed and used many modular systems like the ones you built in this article.

We just posted a step-by-step tutorial on the freeCodeCamp.org YouTube channel that will guide you from a blank project to a fully playable game with a main menu, multiple tower types, enemy waves, and three unique levels. Frank from Frank’s Laboratory developed this course.

You’ll learn how to create a modular, data-driven system using Scriptable Objects to manage towers, enemies, and waves, plus how to design forest, lava, and jungle levels with Unity Tilemaps.

In this tutorial, you’ll learn:

• How to set up 2D Tilemap levels in Unity

• Animate pixel-art characters

• Build towers and spawn enemy waves

• Design diverse game worlds with Tilemaps

• Export builds for Windows, Android, and Web

• Publish and share your game online

Watch the full course on the freeCodeCamp.org YouTube channel (10-hour watch).

We just published a course on the freeCodeCamp.org YouTube channel that will teach you how to create an MMO game from scratch using Unity and SpacetimeDB. I created the course myself! This beginner-friendly course walks you through every step of the development process. The game you'll create is a space-themed version of agar.io, where players control an entity that grows larger as it collects smaller objects while competing with others in real time. By the end of the course, you'll have a fully functional MMO game that can support hundreds of players simultaneously.

Throughout the course, you'll gain hands-on experience with:

• Unity Game Development – Learn how to build and design your game using the Unity engine.

• C# Programming – Write scripts to control player movement, interactions, and game mechanics.

• SpacetimeDB – Implement a real-time multiplayer database to manage player data efficiently.

• Server and Client Architecture – Set up the game’s backend and handle communication between players.

• Multiplayer Game Mechanics – Create a competitive, interactive game world where players can grow, compete, and strategize.

This course is perfect for beginners, though some prior experience with Unity or C# can be helpful. However, even if you're completely new, I will break everything down step by step, to make sure anyone can follow along and build their own MMO.

If you've ever wanted to create your own online game, this course is a great starting point. Check it out now on the freeCodeCamp.org YouTube channel.

We just published a course on the freeCodeCamp.org Spanish YouTube channel that will guide you step by step through the fundamentals of C# for Unity. You will learn the core concepts that you need to know to start developing games in Unity with C#.

If you have Spanish-speaking friends, you are welcome to share the Spanish version of this article with them.

Luis Canary created this course. He is the Principal Gameplay Programmer at Pendulo Studios, a Madrid-based video game development company. He has taught courses at universities, schools, and companies and loves to share his passion for game development on his YouTube channel.

Before we dive into the course content, let's see what C# is, how it is related to Unity, and why you should learn both of them.

What are C# and Unity?

C# is a versatile programming language known for its simplicity and power. Designed by Microsoft, it's part of the .NET family, a set of tools, libraries, and programming languages that work together to build various applications.

C# is a popular choice for building a wide range of applications, from desktop software and web applications to mobile apps and video games.

This course will focus on the fundamentals of C# for game development with Unity.

Unity is a popular game engine for creating 2D and 3D experiences. It uses C# as its primary scripting language and includes a comprehensive set of tools and features to design, develop, and deploy games across various platforms.

These are the platforms that are currently supported by Unity:

• Desktop

• Mobile

• Web

• Consoles

It also supports Augmented Reality (AR) and Virtual Reality (VR).

By learning C# for Unity development, you will be taking your first steps into a career in game development.

💡 Tip: This course is perfect for anyone who wants to start developing video games. It covers core programming concepts that will remain valid across different versions of C# and Unity.

C# for Unity Course in Spanish

Awesome. Now that you know more about C# and Unity, let's see what you will learn during the course:

• Variables

• Operators

• Conditionals

• Switch Statements

• While Loops

• Do-While Loops

• For Loops

• Arrays

• Lists

• Foreach Loops

• Functions

• Methods

• Modifying components

• Coroutines

• Invoke

• Destroy

• PlayerPrefs

• Classes

• Inheritance

By the end of the course, you will know the fundamentals of C# for Unity and you will be ready to start developing games in this programming language.

If you are ready to start learning C# for Unity, check out the course on the freeCodeCamp.org Spanish YouTube channel:

✍️ Course created by Luis Canary.

• YouTube: @LuisCanary

• Instagram: @luiscanary_

• Twitter: @luiscanary

• TikTok: @luiscanary

• Twitch: LuisCanary

• Discord: Invitación

• Facebook: LuisCanaryy

💡 Tip: Once you've completed this C# for Unity course, we recommend taking a general introduction to Unity course to learn the basics of the user interface and the features of your current version of Unity.

3 May 2018.

Here's one thing that got the ball rolling:

Luigi: Hello Andrea. Sorry to bother you. I would like to learn how to develop an app. Am I crazy?

Me (Andrea): Hmm... I don't have your number... who are you?

Reading those two WhatsApp messages now makes me smile. But there are also two other pieces of interesting information:

First, that was May 2018. Now it is 2022... 3 years and some months later, we have published our very first game DEMO. So yes, it took us 3 years to release a demo.

But we are now producing at a steady pace, and in the first months of 2023 we will release the whole game.

That said, if you are planning to develop a game yourself, it won't necessarily take you 4 years…and I have some advice that hopefully will help!

Second, an app – everyone wants to make an app. Do we really need another app? What about a game instead? What I mean is: an adventure game is like a book, you install it, play it, enjoy and eventually uninstall it. It is not yet another app polluting your phone's memory.

Before I start, let me step back and explain what this article is about.

What We'll Discuss in This Article

This article is about how I (Andrea) and Luigi developed Occulto, our first adventure game.

It will cover some technical aspects of the project, as well as how we managed creating and developing it. I'll discuss both psychological and practical parts of the journey.

I'll also provide a shallow comparison between using web technologies (like WebGL) for development vs Unity 2D.

This article consists of:

• A brief story about my passion for Adventure P&C games, and how I ended up developing my own game.

• A section about Occulto, the game I am developing

• A tech section with a comparison between web technologies and Unity 2D

• A section about what I learned through the process, along with some advice if you're creating your own game.

How I got Into Adventure Games

Many years ago, a good friend introduced me to Machinarium. Machinarium is one of the best adventure games I've ever played.

After I finished it, I felt the need to create my own adventure game. This feeling was not immediate, but grew stronger over time. Eventually it led me to find Luigi and be actually able to create my own indie game.

First adventure game attempt

In my first attempt at building a game, I contacted some friends and created a small group of people who were enthusiastic about creating an artistic P&C game.

We managed to create a draft of the first scene (see the illustration above). The idea was to make an apple fall on Newton's head, who is resting under the tree.

I used the Playn Java framework to write in Java and export to Android, iOS and web. At the time I was a Java developer. Playn is still an active project, it may be worth considering if you are looking for a Java 2D game framework.

This first attempt didn't last long. We had a dinner all together, and asked two friends to present us with a draft story of the game. And then I didn't get any feedback from the others and the project vanished into nothing.

Second attempt

In my second attempt I managed to create four scenes and some game-play among them. But the project failed because I wasn't ready to lead the project. You'll read about that soon.

Below you can see an image of one of the scenes of the game. It was intended to be a modern revisiting of Little Red Riding Hood were wolves were not bad :).

Third and Final Adventure Game Attempt: Occulto

Developing Occulto is my 3rd attempt at creating an adventure game – and hopefully this one is successful!

Unity Editor: 1° Village

Intro to the game

It is a beautiful morning, and Eliot, a young mage apprentice, is going to the studio of his magister for a lesson about magical potions. Something is wrong from the first moment: why isn't the magister opening the door?

Inside the studio everything is a mess, and a note tells Eliot to go to the church in the village. What is going on? Where is the magister?

2° Magister studio

Will you help Eliot in his journey to find his magister and regain possession of the powerful forbidden book titled "The never written book" that an evil figure is trying to steal?

The demo consists of four scenes:

3° Monastery

and one secret passage between the monastery and the private studio of a monk.

4° Secret passage

Below you can see the last scene of the demo.

5° Monk private studio

Tech I Used to Build My Adventure Game

We developed Occulto in the beginning using Pixi.JS and HTML. Then, later, I switched to Unity using the 2D features that are now included as default in the editor.

Since this article is quite long, I will not enter in the details of the code. But I will provide a description of the technologies we used and the process of creating the game.

I am planning to write a second article for the technical part.

We are a group of 3 people:

• Myself, Andrea, the developer and project/technical manager. I contribute to the story and game/riddle design as well. I am a software engineer.

• Luigi, the wonderful artistic designer who designs and draws the scenes. He is also responsible for the game story and game-play. If you like the illustrations above, then you like Luigi's work :). He graduated in Mathematics.

• Antonio is the music and sounds designer. He is a software engineer.

Luigi draws the scenes using Photoshop and makes the animations using After Effects. Then he exports everything into images (jpg and png) that I later use to assemble the scenes.

In addition Antonio provides me with the sounds and music for the scenes. We are using mp3 files at the moment, but we are planning to switch to FMOD in the future.

The game uses FHD (1920x1080) images, and runs also on low end mobile devices. If you want to run on a device with 1 GB of RAM, you need to reduce the amount of FHD images. If you load in memory more than 50/60 FHD images, the game may crash on devices with not enough memory.

In normal Unity memory management, the entire scene is loaded on memory, so you have to pay attention to what you add to the scene.

A simple and classic solution to reduce the memory imprint, is to use sprite sheets for the animations. Most of the time an animation will fit in a 2048x2048 sprite. I use Texture Packer to create and import animation sprite sheets in Unity.

In addition I use ImageMagick CLI to trim images with an object inside. My input is a FHD transparent PNG with an object inside placed in the right position. Then I use:

magick mogrify -trim -verbose *.png > trim.txt

to trim the image and get the precise position of the object.

Finally I add the trimmed image to the scene and place it using a script I made that maps the coordinates inside trim.txt file to the x,y values of the Unity scene.

By trimming and using sprite-sheets, I solved all memory problems. Also smaller images means lower time when loading a scene. In cheap mobile devices, loading a scene can require like 5 or 6 seconds (whereas in more powerful devices it takes less than a second).

Regarding fps and performance, Unity is good – so basically you don't have to do anything special. You just need to avoid bad design. And pay attention to time complexity. For example, avoid searching for an element on every tick of the game loop.

As I mentioned earlier, I am planning to write a tech article about how I developed the game using Unity 2D. If you are interested, follow me or follow us on one of our social accounts.

Unity vs WebGL

Even if I used both technologies, I am not an expert (this is my first game). So below I will just list some of the pro and cons of both technologies.

Pros of WebGL

• Easy to port everywhere with Capacitor or Electron.

• Programmers friendly: PixiJS makes it very easy.

• Almost the only working solution if you need a web responsive version.

• Continuous integration and delivery to web is very easy, since the output is a bunch of files.

• Web development is mature, and you have access to tons of libraries, utilities as well as a web packers, like Webpack.

• Collaboration is very easy and mature with Git. There is something about collaboration in Unity, I didn't explore it. I don't know what happens if two people work on the same scene.

Cons of WebGL

• Slightly lower performances compared to more native frameworks.

• Subject to WebViews bugs (which you cannot solve).

• It can be difficult for programmers who do not know web development.

• WebViews doesn't seem to be ready to perfectly support WebGL. The game wasn't working well on my Neffos, and who knows on which devices it had issues. Maybe WebViews are not yet ready for gaming, but they are definitely ready for HTML and hybrids app.

Pros of Unity

• Graphical editor: it is easier to visualize/update the scene and fine tuning.

• Easy and complete: it has almost everything you need.

• Good performance: 60 fps even on low end devices at 1920 x 1080 resolution.

• Cross platform, but the WebGL version does not work well on mobile phones.

• A lot of indie games are made using Unity. If the Unity team introduces a bug, it will be found very soon.

Cons of Unity

• Graphical editor: you need a working updated Unity editor in each of the computers you are going to use. With Linux it's not that simple.

• Closed licence but it has a free tier if you earned up to $100K in the last 12 months.

• At the moment the mobile web version is not officially supported.

• Linux Unity editor is alpha (and I managed to make it work after many attempts).

• Not a lot of helpful info about it: most of the posts I read to find help about a particular topic were low quality or were videos. That's far away from stack overflow quality. But the documentation is well done.

Keep in mind that this section is not intended to be an exhaustive comparison between Unity 3D and WebGl frameworks. Depending on your target, one technology could be better than the other.

That said, even if I am a web developer, I must admit that Unity is great for developing a 2D games (and I guess 3D games too).

What I learned While Building Occulto

Someone needs to lead the project

This is my first insight: if it is you who propose a project to others (a game, an app or whatever), they will assume you will lead the project.

At the time I was thinking that I was just a programmer, and didn't act like a project leader. It won't work if someone doesn't actively follow every person in the project.

Have the right attitude

It is important to have the right attitude towards people that are participating in the project. You also need to understand if they can be productive.

In this context, "productive" does not have the same meaning it has at work. Productive means "actually able to produce". At work it means how much you produce and how good is your output.

Before I go on, let me tell you a story:

Before embarking on Occulto game development, I decided to help a guy develop the interface for his board game. I did it because I thought the game he invented was a good game that had some brilliant parts to it.

In this case I was the developer, and he was leading the project (being the inventor of a game, doesn't unfortunately imply that you are also good as a project leader).

In the beginning everything was good, and I enjoyed developing the game. In addition I was learning React, which I used as the framework to build the game app. (It is a board game, not a classic one, so React was a good choice, and also it had a lot of pages, not just the game page).

Then things started to become weird: he started asking for deadlines, complaining about delays on the development, and asking for features which I thought weren't really useful in the first version of the game.

In the end it didn't work out and I couldn't work well with him, so I blocked all communication. Remember that I worked on his game for free, and I even solved a nasty bug that caused the back end side of the game to stop working.

So, why this story? To tell you that making a game with a bunch of friends is a very different job than what you do at work. Some advice:

• Don't push people too hard: if you are making a game for fun, it must be fun. Motivate people and help them. They are working (as you are) for free on a project they believe in.

• Don't act like a boss: even if you direct and follow every step of the game, people should regard you more as a project manager/team leader than a boss.

Work in your spare time

Being able to be "productive" applies also to you. Are you able to work in your spare time on the game? Can you provide a steady output, without long periods of time away from the project?

This is the first obstacle I encountered in my previous attempts. I wasn't able to provide a constant, timely output and people thought the project was falling apart.

In this case, as a programmer, it is important to integrate the output of your other team members (images, animations and sounds) as soon as possible. People will be more engaged if they see their work quickly integrated in the game. Also the sooner you integrate others' work, the sooner you will find and solve problems.

Remove as many obstacles as you can

In order to work in your spare time, you have to reduce or remove all the obstacles. These can be physical (slow computer, too small a screen, ...) or psychological. The psychological ones are the most subtle. I will try to list some of them:

Feeling guilty for not working: this is hard, and I think is one of the main reasons for quitting. You have to enjoy working on your project. So deadlines, pushing others to produce more, threatening (like "If you don't work enough you are out") do NOT work.

It is better to motivate people and help them understand what's blocking them (or you) to produce some output.

Obstacles that delays the moment you can actually work: you may think something like "I'd like to finish that thing I started, I think I can complete it in 10 minutes." Then you think: "But the PC is slow and it will take forever to start... may be tomorrow, now I'll just serf on Instagram".

It is important that when you think you can work a bit on the game, you can actually do it without any delay or obstacle.

Too tired to work on the game: indeed you must not overdo it. It is important to find a balance between how much you work and how much you rest. But it is also important to avoid long periods of not working on the game.

I noticed that small actions can help: for example for me it is enough to start the Unity Editor to increase the chances that I'll actually work on the game.

Share your results with the others: even though non technical people may not fully understand what you are doing (and vice-versa), it is satisfying to explain that you solved a performance problem, or that you reduced the bundle size, for example.

In fact, in agile methodologies, telling what you did and what your are going to do is one of the main points.

Persist. Not everything will be easy. You will have to persist. Even though you are probably making a game because of passion, it is still requires a lot of work and sometimes you have to persevere and overcome problems/blocks. You probably do that all the time at work, you can do it also for your game.

Not every moment is a moment of pleasure. Imagine when I discovered that the demo, almost ready to be published, wasn't working on some mobile devices and I had to rewrite everything in Unity. I really had a bad weekend.

But then I manage to change my attitude, start with Unity, and regain pleasure in working on the game.

Fortunately Luigi, my partner in the game, understood it and accepted that we needed to delay the release date of the game demo. While it took a lot of time to write the demo (2 years, if you count from the first commit), it took me 3 months to rewrite it.

Focus on developing the game

It is extremely important to focus on making the game, and not the framework for the game.

Being a programmer you will probably want to write more code than necessary and use your preferred language. Chose a framework based on your needs (cross platform? 2D or 3D? ...) and try to develop a simple level to understand if you made the right choices.

When you start, you won't necessarily have a clear view of the possible frameworks/technologies available to build a game – and there are a lot. In addition you will be biased towards some languages/features.

About that, I can tell you 2 mistakes I made:

I used PixiJS and HTML technologies at first. As opposite as you may think, I was able to go at 60 fps with FHD (1920x1080) resolution even in medium performance mobile devices.

This is because most of the work is done by WebGL. But at a certain point the game started flickering on my old mobile phone (Neffos X1 Max) when ported to a mobile app using Capacitor (webview). But it was working well on the browser and on the other phones I had. Even on my Motorola Moto G first generation (2013 low end device).

I should have tested earlier on mobile (not just with the browser). Also the game wasn't smooth on the my lower end device Moto G (still it was running near 30 fps).

I decided that I wanted my game to run smoothly even on low end devices, so I switched to Unity 2D. Unity is used by a lot of indie game developers, and C# is quite easy. I didn't try Unreal Engine, because I am too rusty on C++. Now it runs smoothly also on my Moto G (60 FPS).

The second thing that was almost a mistake is that I developed a library to find the shortest path on polygon areas with polygon holes. Here you can find the JS code (I have ported it to C#, but not yet release on GitHub).

I took me 3 attempts to get it working properly, and a lot of time. Fortunately by the time I started developing Occulto, the library was ready and working. Now I can just draw the walkable area and have the main character move inside it, avoiding obstacles (polygon holes).

The fact is that having an algorithm to move things inside a walk-able area is not strictly necessary, and it is better to focus on actually making the game. Other P&C games do not use this feature, they just move characters along predefined paths.

So, before you embark on something that is not strictly necessary for the game, see if you can find something already implemented or if it is really worth it.

Release a one scene version of the game

After you've chosen the right framework, take a scene, and develop the entire game which will consist on one scene plus a menu and every UI component that is cross scene. It is important to learn everything you need and to find problems as soon as possible.

Also, submit the game for internal testing (not public) to the stores you are going to use. Yes, do everything that's necessary from developing to publishing (privately) the game.

When I published the game demo on iOS, one animation wasn't working. It was working on Android, Desktop, and even on iPhone with the developer build. So yes, you need to test everything as soon as possible, even the process of publishing.

I made the mistake to first develop the whole demo (four scenes, plus menu and some other screens) just to find out that WebGL technology was not the right choice for my game.

Final Notes

I hope you enjoyed reading this article and found some interesting advice. Maybe I will write another article when I have published the whole game, sharing other insights.

If you are curious about Occulto game, follow us on:

• Twitter: https://twitter.com/SirioArtGames

• Instagram: https://www.instagram.com/sirioartgames

• Our website: https://www.sirioartgames.com

or try the demo: http://onelink.to/occulto!

In this article, I will talk about the different game engines and tools that you can use to build your own games. I will also provide you with dozens of resources and tutorials to help get you started.

There are many tools and game engines out there but I will cover a few of the popular ones.

1. Unity
2. Unreal Engine
3. Godot
4. Phaser
5. GameMaker Studio
6. CryEngine
7. Amazon Lumberyard
8. Ren'Py Visual Novel Engine
9. Pygame
10. LÖVE
11. Kaboom.js

Unity

This is a cross platform video game engine that is popular with game developers. Unity supports many platforms including iOS, Android, Windows, Mac, Linux and game consoles such as PlayStation and Xbox.

Some popular games that have been built with Unity include Cuphead, Pillars Of Eternity, Ori And The Blind Forest, Escape Plan, and Hearthstone.

Unity provides you with the opportunity to create your own 2D and 3D games. You can create shooter games, platformer games, educational games and more with Unity.

The programming language used with Unity is C#. If you are new to C#, you can take this freeCodeCamp YouTube course.

To get started with Unity, you can sign up for a free plan on their website. They offer free plans for both students and individual use.

Unity also provides hours of courses, project tutorials, live training sessions and certifications. All of this education is available on their website.

freeCodeCamp also provides many resources to help you get started.

• Game Development for Total Beginners - Free Unity Course
• Learn Unity Multiplayer Basics with Mirror
• Learn C# and Unity by Making Digital Tabletop Games
• Unity Game Engine Guide: How to Get Started with the Most Popular Game Engine Out There

Unreal

Unreal is a game engine where you can build 3D games. Unreal supports many platforms including iOS, Android, Windows, Mac, Linux and game consoles such as PlayStation, Xbox and Nintendo Switch.

Popular games built with the Unreal game engine include Fortnite, Yoshi's Crafted World, Hellblade: Senua's Sacrifice, Street Fighter 5, and Star Wars Jedi: Fallen Order.

The programming language used with Unreal is C++. If you are new to C++, you can take this freeCodeCamp YouTube course.

You can download the Unreal game engine for free on their website. They also provide 100's of hours of free online tutorials.

freeCodeCamp also provides many resources to help you get started.

• Learn Unreal Engine 4 by Coding 3 Games - A Free 5-hour Game Dev Video Course
• Unreal Engine Course: Create a 2D Snake Game
• How to Build A 2.5D Platformer Game With Unreal Engine – a Free 3-hour Course

Godot

Godot is a free open source game engine designed to create 2D and 3D games. Godot supports many platforms including iOS, Android, Windows, Mac, and Linux.

Some popular games that have been built with Godot include Carol Reed Mysteries, Commander Keen in Keen Dreams, and Cruelty Squad.

Godot supports a few programming languages but the main ones are GDScript and VisualScript. To learn more about supported languages, please visit the documentation.

To get started working with Godot, you can go to their download page. Godot provides many free tutorials in their learn section.

freeCodeCamp also provides this YouTube tutorial on Godot.

Phaser

Phaser is a free open source platform where you can build HTML 5 games for mobile and desktop. Phaser supports iOS, Android, as well as like Apache Cordova and phonegap.

Phaser provides you the opportunity to create your own shooter games, platformer games, educational games, and more. The primary languages used are JavaScript and TypeScript.

If you are new to either of those languages you can look into these freeCodeCamp beginner tutorials.

• Learn JavaScript - Full Course for Beginners
• Learn TypeScript - Full Course for Beginners

To get started working with Phaser, you can go to the download page on their website. Phaser offers dozens of free tutorials to help you get started creating your first games.

If you have experience working with Node, Express, Vue or Socket.IO, then you can look into these tutorials.

• How to Build a Multiplayer Tabletop Game Simulator with Vue, Phaser, Node, Express, and Socket.IO
• How to Build a Multiplayer Card Game with Phaser 3, Express, and Socket.IO

GameMaker Studio

GameMaker Studio is a cross platform video game engine where you can create your own 2D games. GameMaker supports many platforms including iOS, Android, Windows, Mac and game consoles such as PlayStation and Xbox.

Popular games made with GameMaker Studio include Undertale: Overwhelmingly Positive, Shovel Knight: Treasure Trove: Overwhelmingly Positive and Katana Zero: Overwhelmingly Positive.

GameMaker Studio uses the GameMaker Language and you can learn more by visiting the documentation.

They also offer dozens of tutorials to get you started making games. Gamemaker has a free option and you can create an account on their website.

CryEngine

CryEngine allows you to create interactive 3D games and supports platforms like Windows, Linux, PlayStation, Xbox, and Oculus Rift. You can create shooter games, platformer games, educational games and more with CryEngine.

Some popular games that have been built with CryEngine include Kingdom Come: Deliverance, Far Cry, State of Decay, and Ryse: Son of Rome.

Programming languages used for CryEngine include C#, C++, and Lua. If you are not familiar with those languages, then you can look into these resources.

• C# Tutorial - Full Course for Beginners
• C++ Tutorial for Beginners - Full Course
• Lua Get Started Guide

CryEngine has dozens of tutorials to help you get started building games and it is free to download on their website.

Amazon Lumberyard

Amazon Lumberyard is a free cross platform video game engine where you can create your own 3D games. Amazon Lumberyard supports many platforms including iOS, Android, Windows and game consoles such as PlayStation and Xbox.

Some games using Amazon Lumberyard include New World and The Grand Tour Game.

Programming languages used for Amazon Lumberyard include C++, and Lua. If you are not familiar with those languages, then you can look into these resources.

• C++ Tutorial for Beginners - Full Course
• Lua Get Started Guide

Amazon Lumberyard is free to download and there are dozens of tutorials to get you started building your own games.

Ren'Py Visual Novel Engine

Ren'Py Visual Novel Engine is a free engine where you can create interactive visual novels and games. Ren'Py supports many platforms including iOS, Android, Windows, Mac, and Linux.

Some popular games and novels created with Ren'Py include, Doki Doki Literature Club!, Zero Deaths, and UFO Swamp Odyssey.

The programming language used with Ren'Py is Python. If you are new to Python, you can take this freeCodeCamp YouTube course.

You can download Ren'Py for free on their website. They also provide a Quickstart guide to creating your first game or novel.

freeCodeCamp also has a walk through tutorial on how to make a visual novel game using Ren'Py.

Pygame

Pygame comes with modules, sounds, and graphics to allow you to create video games using Python. Pygame supports platforms including Linux, Mac and Windows.

Popular games built with Pygame include Frets on Fire and Dangerous High School Girls in Trouble!

The programming language used with Pygame is Python. If you are new to Python, you can take this freeCodeCamp YouTube course.

To get started with Pygame, you can go through their Getting Started guide on their website. freeCodeCamp also has a YouTube course on getting started with Pygame.

LÖVE

LÖVE is a free game engine where you can build 2D games. LÖVE supports many platforms including iOS, Android, Windows, Mac, and Linux.

Some popular games that have been built with LÖVE include Blue Revolver, Move or Die, and Warlocks Tower.

The programming language used for LÖVE is Lua. You can learn about Lua in their get started guide on the website.

Kaboom.js

Kaboom.js is a library that allows you to build computer games using JavaScript. If you are unfamiliar with JavaScript, then you can take this freeCodeCamp YouTube course.

To get setup, you can use their CDN, NPM or official Replit template. All of the information to get started can be found on their website.

Kaboom.js also provides a walk through tutorial to building your first game. You can recreate classic games like Mario and Space invaders using Kaboom.js.

You can also go through this freeCodeCamp YouTube course, to get started building classic games.

I hope you enjoy my list of popular game engines and tools to get started learning how to build your own games.

I encourage to keep exploring and find even more game options that were not mentioned in this article so you can continue your learning.

Best of luck on your game development journey.

In this article, I'll teach you how to make a basketball using materials and textures in Unity. You can extend this micro-concept to create any kind of ball like a football, tennis ball, or snooker balls.

That said, these techniques aren't just limited to creating round 3D objects like balls. You should be able to use this concept to customize the look of any type of geometry (or mesh).

Here is what you will create👇🏻

Basketball🏀

Think of the basketball as a sphere (that is, a mesh) wrapped up with a pretty paper (that is, a texture).

Let’s get started.

Prerequisites

To make the bouncing ball, your sample scene should have  the following:

1. A plane
2. A sphere with a custom material

Let's see how to do that first.

Step 1: How to Add a Plane and a Sphere to the Scene

First go to the Hierarchy Panel in Unity. Right click and select plane to drop a plane in your scene. Do the same to add a sphere.

Add a plane and a sphere to the scene

Step 2: How to Create a Folder that Contains All the Colors

It’s always a good practice to begin by creating a folder that contains all your colors and materials. This helps you create a palette (or a collection of colors and materials) and makes it easier for you to apply the assets in your palette to the Game Objects.

Simply go to the Projects panel. Then right click in the assets sub-panel, click create, and then select folder. Name this folder "Materials".

Right-click in Assets Panel > Create > Folder > Name it “Materials”

Step 3: How to Create a Material for the Plane

The next step is to create colors (or materials) for the plane.

Go inside the materials folder that you created in the above step by double clicking on it. Right click and select create. Then select "Material" from the dropdown.

Go inside Materials Folder > Right-click > Create > Material > Name it “MyColor”(or whatever you want)

Step 4: How to Change the Albedo Property of the Material

Next select the created material and check out its properties in the Inspector Panel on the right-hand side.

Note that you only need to change the albedo property of the plane's material and not the sphere's material. We will create a material for the sphere later in this article.

It is important that your sphere has a custom material in this step. Otherwise, you will not be able to view or modify the various properties of the Material.

Change the “albedo” property to whatever color you want.

Great! Now you can create a collection of colors using the same technique.

Now we can apply the color to any Game Object like this👇.

Drag and drop the material into the Game Object (in our case it will be a plane instead of a cube)

Step 5: How to Add the Rigidbody Component to the Ball

Since we need our ball to obey the laws of physics, we will have to attach the Rigidbody component to it.

To do so, select the Sphere from your Scene Hierarchy panel. Click on Add Component and then make sure the "Use Gravity" box is checked. We don’t want the ball to float off into space 😅.

Select the Sphere > Add Component > Rigid Body > Keep “Use Gravity” box checked

Step 6: How to Create a "Bouncy" Material

Go to the assets panel. Right click and then click create. Make sure you select the "Physic Material" and not Material. Name the material anything you want to. I named it "Bouncy" for obvious reasons.

Right-click in the assets panel > Create > Physic Material > Name it “Bouncy”

Step 7: How to Change the Properties of the Bouncy Material

Select the Bouncy Material. You should be able to view the properties of this material on the right-hand side in the the Inspector panel. Now change the properties.

Set Friction to 0 and Bounciness to 1

Step 8: How to Apply the Material to the Sphere

Now apply this material to the sphere (that is, the ball) in our scene by simply dragging and dropping the bouncy material to the sphere.

Drag and drop the Bouncy Material into the Sphere

That’s it! 🎉 This step confirms that the sphere will bounce on the floor.

Step 9: Hit the Play Button

On top of the Game panel you will find the play button. Click on it and the ball will start bouncing.

Our ball is bouncing now. Yayyy!

Notice how the bouncing stops after some time. This is expected behavior and we will fix this in the next step.

Step 10: How to Change the Properties of the "Bouncy" Material

Different balls bounce differently. You can control the number of times the ball bounces. Try experimenting with different properties of the “Bouncy” material.

Select the "Bouncy" material in the Materials folder and try changing the values of the properties. If you want the ball to bounce forever set the value of Bounce Combine to Maximum.

Set the value of Bounce Combine to Maximum and our ball won’t stop bouncing at all

Alright. Now let's make that ball look like a real basketball.

Step 11: How to Create a Folder that Will Contain All Your Textures

To keep things organized, let’s create a folder that will contain all the textures.

To do so, go to the assets panel and create a new folder called "Textures". This is where we will store all our textures.

Right-click in Assets Panel > Create > Folder > Name it “Textures”

Step 12: How to Download a Texture

Since we need a texture for a basketball, simply download one online. A texture is just an image in .png or .jpg format. For now, you can download the basketball texture from here:

Make sure you have the appropriate license to use a texture that you download. The above textures are free to use.

Step 13: How to Drop the Texture into your Unity Project

Simply drag and drop the textures into the Textures folder as shown below👇

Drag and drop the downloaded texture into the “Textures” folder that you created in Step 1 above.

Step 14: How to Apply the Downloaded Texture to the Sphere

Select the sphere to view all its properties in the Inspector panel. Then drag and drop the "BasketballColor" texture to the square box on the left hand side of the Albedo property.

Drag and drop the downloaded texture to the box at the left of the Albedo property.

You've successfully used Materials and Textures to create a basketball. Now you can do the same for all your games or AR/VR experiences that you develop.

Different types of balls behave differently. Try experimenting with the bounciness and tweaking the different parameters of the Rigid Body Component attached to the sphere to create a golf ball, a football, or a tennis ball.

Enjoy!👏🏻

You can connect with me on social media here:

• Twitter id: @knightcube
• Subscribe to my YouTube channel to learn more about AR/VR
• Read more articles on my Medium profile here

We just published a 7-hour course on the freeCodeCamp.org YouTube channel that will teach you how to create games using Unity. This is the perfect course for a complete beginner.

Fahir from AwesomeTuts developed this course. He has been creating Unity tutorials for years and he knows exactly what beginners need to know.

The course starts with teaching how to install Unity, an overview of using Unity, and the basics of C#. Then you will learn how to create a complete game from start-to-finish. And all the assets you need are included for free—just check the links in the video description.

Here are all the sections in this course:

• Downloading Unity And Unity Hub
• About Unity Versions And Creating A New Project
• Introduction To Unity's Interface
• Starting With Unity's Basics
• Rigid Bodies And Colliders
• Audio Source And UI Elements
• Moving Our Character With Code
• Introduction To Variables
• Operations With Variables
• Functions
• Conditional Statements
• Loops
• Coroutines
• Classes
• Accessibility Modifiers(Data Encapsulation)
• Inheritance
• Getting Components
• Monster Chase Game Intro
• Importing Assets
• Creating Player Animations
• Sorting Layers And Order In Layer
• Creating The Game Background
• Player Movement
• Animating The Player Via Code
• Player Jumping
• Camera Follow Player
• Enemy Animations
• Enemy Script
• Enemy Spawner
• Enemy Collision
• The Collector Script
• Unity's UI System
• Creating Main Menu
• Navigating Between Scenes
• Selecting A Character
• Static Variables
• Singleton Pattern
• Events And Delegates
• Instantiating The Selected Character
• Finishing Our Game

You can watch the full course below or on the freeCodeCamp.org YouTube channel (7-hour watch).

Unity is one of the most well-known and established engines for game development, and Mirror is a third-party, open source networking solution that allows you to add multiplayer to your games.

With this new tutorial, we'll walk through the basics of Unity multiplayer development with Mirror!

Follow along (57 minute watch):

You can continue by learning how to build a 2D multiplayer card game with Unity here.

Happy coding!

If you enjoyed this article, please consider checking out my games and books, subscribing to my YouTube channel, or joining the Entromancy Discord.

M. S. Farzan, Ph.D. has written and worked for high-profile video game companies and editorial websites such as Electronic Arts, Perfect World Entertainment, Modus Games, and MMORPG.com, and has served as the Community Manager for games like Dungeons & Dragons Neverwinter and Mass Effect: Andromeda. He is the Creative Director and Lead Game Designer of Entromancy: A Cyberpunk Fantasy RPG and author of The Nightpath Trilogy. Find M. S. Farzan on Twitter @sominator.

Building 2D games can be a great way to learn C# and Unity, especially when working through the basics of complex tabletop game logic.

In this series, I’m going to introduce you to the basics of C# programming using Unity. But a lot of the concepts we’re going to learn will be applicable in other programming languages as well, and game development in general.

Throughout this series, I’ll be providing an emphasis on learning Unity for digital tabletop game development. This should be useful for anyone who wants to learn to code in C# or work with Unity.

After learning some C# and getting comfortable with the Unity editor, along with some practice projects and outside learning of your own, you’ll be able to run simulations, make your own games, and begin exploring the wider Unity ecosystem.

If you’re not specifically interested in digital tabletop game development, you’ll probably still find this series to be helpful. We’ll be learning core concepts that are central to C# coding and Unity game development that you’ll be able to apply to other programming languages and engines.

I’m a big proponent of using digital tabletop games in learning to code. Tabletop games are great because they involve a lot of logic and complex rulesets, but not physics, vector math, animation, and that sort of thing.

Start by learning the basics (Beginner Series):

Take a tour of Unity 2D (Beginner Tutorial):

Learn Unity multiplayer basics with Mirror (Intermediate Tutorial):

Build a 2D multiplayer card game (Advanced Series):

Happy coding!

If you enjoyed this article, please consider checking out my games and books, subscribing to my YouTube channel, or joining the Entromancy Discord.

M. S. Farzan, Ph.D. has written and worked for high-profile video game companies and editorial websites such as Electronic Arts, Perfect World Entertainment, Modus Games, and MMORPG.com, and has served as the Community Manager for games like Dungeons & Dragons Neverwinter and Mass Effect: Andromeda. He is the Creative Director and Lead Game Designer of Entromancy: A Cyberpunk Fantasy RPG and author of The Nightpath Trilogy. Find M. S. Farzan on Twitter @sominator.

Working with the canvas in Unity 2D can feel complicated at first, particularly if you're attempting to learn the editor while also tackling C# scripting.

It can also be daunting to think about turning a single-player game into a multiplayer experience, as there are a lot of new concepts to consider and several third-party packages from which to choose.

In Part 1 of this new video series, we'll create a basic 2D card game in Unity with randomized decks and draggable/droppable cards using the canvas, C# scripting, prefabs, and more (1 hour 10 minute watch):

In Part 2, we'll continue the adventure by cleaning up our nested canvas prefabs and enabling a mouseover card preview (42 minute watch):

In Part 3, we'll add basic multiplayer functionality with Mirror (1 hour 26 minute watch):

In Part 4, we'll continue to work with Mirror to improve our multiplayer experience (36 minute watch):

In Part 5, we'll add game logic from one of my games, Entromancy: Hacker Battles, to our multiplayer project (2 hour 34 minute watch):

And in Part 6, we'll continue to add game logic along with a more robust user interface (1 hour 23 minute watch):

You can also learn more about Unity multiplayer basics here.

Happy coding!

If you enjoyed this article, please consider checking out my games and books, subscribing to my YouTube channel, or joining the Entromancy Discord.

M. S. Farzan, Ph.D. has written and worked for high-profile video game companies and editorial websites such as Electronic Arts, Perfect World Entertainment, Modus Games, and MMORPG.com, and has served as the Community Manager for games like Dungeons & Dragons Neverwinter and Mass Effect: Andromeda. He is the Creative Director and Lead Game Designer of Entromancy: A Cyberpunk Fantasy RPG and author of The Nightpath Trilogy. Find M. S. Farzan on Twitter @sominator.

Unity is a cross-platform game engine developed by Unity Technologies, which is primarily used to develop video games and simulations for computers, consoles and mobile devices. First announced only for OS X, at Apple’s Worldwide Developers Conference in 2005, it has since been extended to target 27 platforms.

Overview

Unity is an all purpose game engine that supports 2D and 3D graphics, drag and drop functionality and scripting through C#.

Unity is particularly popular for mobile game development and much of their focus is on mobile platforms. Unity3D’s 2D pipeline is a more recent addition to the engine, and is less mature than the 3D pipeline. Despite this Unity is an adequate platform for developing 2D games even when compared to other dedicated 2D engines, particularly if you plan to release the game across multiple mobile devices.

Unity is also a good choice for VR development, although VR is a very small market at the moment. The mobile and PSVR markets are the largest in VR, and Unity is already well positioned to port games to many platforms such as PS4 and PC, or many different mobile markets.

The engine targets the following graphics APIs: Direct3D on Windows and Xbox One; OpenGL on Linux, macOS, and Windows; OpenGL ES on Android and iOS; WebGL on the web; and proprietary APIs on the video game consoles.

Additionally, Unity supports the low-level APIs Metal on iOS and macOS and Vulkan on Android, Linux, and Windows, as well as Direct3D 12 on Windows and Xbox One. Within 2D games, Unity allows importation of sprites and an advanced 2D world renderer.

For 3D games, Unity allows specification of texture compression and resolution settings for each platform that the game engine supports, and provides support for bump mapping, reflection mapping, parallax mapping, screen space ambient occlusion (SSAO), dynamic shadows using shadow maps, render-to-texture and full-screen post-processing effects.

Unity also offers services to developers, these are: Unity Ads, Unity Analytics, Unity Certification, Unity Cloud Build, Unity Everyplay, Unity IAP, Unity Multiplayer, Unity Performance Reporting and Unity Collaborate. Besides this, Unity has an asset store where the developer community can download and upload both commercial and free third party resources such as textures, models, plugins, editor extensions and even entire game examples.

Unity is notable for its ability to target games for multiple platforms. The currently supported platforms are Android, Android TV, Facebook Gameroom, Fire OS, Gear VR, Google Cardboard, Google Daydream, HTC Vive, iOS, Linux, macOS, Microsoft HoloLens, Nintendo 3DS family, Nintendo Switch, Oculus Rift, PlayStation 4, PlayStation Vita, PlayStation VR, Samsung Smart TV, Tizen, tvOS, WebGL, Wii U, Windows, Windows Phone, Windows Store, and Xbox One.

Unity is the default software development kit (SDK) for Nintendo’s Wii U video game console platform, with a free copy included by Nintendo with each Wii U developer license. Unity Technologies calls this bundling of a third-party SDK an “industry first”.

Interface

In picture above, you will notice five section:

1. Section 1. Scene View: This is where you will be creating level for your game, scene or 3D project. All of your Game Objects will be placed and manipulated right here.
2. Section 2. Game View: This is where you will see your results, how your level or scene looks like. You need to have a Camera on the scene to see how it looks like. Sometimes its called Camera View.
3. Section 3. Hierarchy: This window will display all Game Objects placed directly on the scene. Basically everything that you see in Game View, needs to be listed here. This will include non-visual and visual game objects.
4. Section 4. Project: This is your project window. Basically it show whats inside Assets folder on your disk. Everything from Game Objects, Scripts, Textures, Folders, Models, Audio, Video and etc… will be accessible from this window.
5. Section 5. Inspector: This panel will display different attibutes and properties of selected Game Objects. Depending on the selection, the appropriate attributes and components will be listed.

Noteworthy Games:

• Assassin’s Creed: Identity
• Temple Run Trilogy
• Battlestar Galactica Online
• Hearthstone: Heroes of Warcraft
• Inside
• Cuphead

History

Two other programming languages were supported: Boo, which was deprecated with the release of Unity 5 and UnityScript which was deprecated in August 2017 after the release of Unity 2017.1.

Unity formerly supported 7 other platforms including its own Unity Web Player.

Unity Web Player was a browser plugin that was supported in Windows and OS X only, which has been deprecated in favor of WebGL.

Unity is the engine used by Rust, Kerbal Space Program, and Cup Head.

More info on Unity:

• Ultimate beginner's guide to game dev in Unity
• How to create a 2D game in Unity (video)
• Take a tour of Unity 2D (video)
• Comparison of Unity and other game engines

Unity

Probably the most popular engine, Unity, has its own article here. Check it out and learn all about its many features.

GameMaker Studio

GameMaker Studio, previously known as GameMaker, is a cross-platform game development software primarily focused on creating 2d games using drag and drop action sequences or a scripting language known as Game Maker Language (GML).

Overview:

GameMaker allows it’s users to create and prototype games quickly without the need to learn a programming language. GameMaker games usually consists of at least 3 things: sprites (images & animations), objects (logic & interactivity) and rooms (screens & levels). Each game needs at least one room which is used for both menus and levels, and the transitioning between each.

GameMaker Studio 2 released on 2 November 2016.

Supported Platforms:

• Microsoft Windows
• macOS
• Ubuntu
• HTML5
• Android
• iOS
• Amazon Fire TV
• Android TV
• Microsoft UWP
• PlayStation 4
• PlayStation Vita
• Nintendo Switch (September 2018)

PlayStation Portable and Raspberry Pi support was demonstrated but not released.

Popular games made with GameMaker Studio:

• Spelunky
• Hotline Miami
• Hyper Light Drifter
• Crashlands
• VA-11 Hall-A
• Undertale
• Nuclear Throne

Unreal Engine

Unreal Engine is a cross-platform game engine developed by Epic Games. The Unreal Engine was initially developed for the 1998 FPS title Unreal, but has been subsequently used for many thousands of commercial and non-commercial titles. The most recent version of the engine, Unreal Engine 4, targets PC, PlayStation 4, Xbox One, Mac OS X, iOS, Android, many VR systems, Linux, SteamOS, and HTML5, and the editor can run on Windows, OS X and Linux.

Uscript is the engine’s native scripting language, used for creating game code and gameplay events before the release of Unreal Engine 4, and was designed for high level programming. The script was written and programmed by Tim Sweeney, also the creator of another scripting language, ZZT-oop.

Since 2015 the Unreal Engine has been free to use, with Epic charging a 5% royalty on sales of titles produced using the engine. Epic make the majority of their codebase freely available via their Github, although source for closed platforms such as the Playstation 4 and Xbox One is only available for registered platform developers.

Unreal Versions

Unreal has gone through 4 major revisions. Although some code is common between releases, each major version is a separate engine and projects cannot be moved between them. Within each major engine release, there are multiple minor versions.

• Unreal Engine 1 Released in 1998 and targeted Windows PC, Linux, Mac, PlayStation 2 and Dreamcast. The engine was written in C++, and easily moddable using the Unreal Script language.
• Unreal Engine 2 Released in 2002 and targeted Windows PC, Linux, Mac, Playstation 2 and Xbox. The engine was written in C++, utilized the Unreal Script language.
• Unreal Engine 3 Released in 2004 and targeted Windows PC, Linux, Mac, iOS, Playstation 3 and Xbox 360. Development is split between Unreal Script and C++, with an additional visual scripting interface called Kismet.
• Unreal Engine 4 Released in 2015 and targets PC, PlayStation 4, Xbox One, Mac OS X, iOS, Android, many VR systems, Linux, SteamOS, and HTML5, and the editor can run on Windows, OS X and Linux. Unreal Script has been removed and replaced with dynamically reloaded C++ modules, and a more advanced visual scripting interface called Blueprints.

Popular Games made in Unreal

• Batman Arkham City
• Mass Effect
• Bioshock
• Borderlands
• Gears of War

Pygame

Game Development with Pygame

Pygame is an open source, cross platform python library used for game development, written by Pete Shinners. The Pygame documentation and more information can be found on their website at https://pygame.org.

Overview

The project started in the year 2000 as a result of the death of PySDL. The Pygame library version 1.0 was released after six months development in April of 2001.

libGDX

libGDX is a free and open-source game-development application framework written in the Java programming language with some C and C++ components for performance dependent code.

Overview

LibGDX supports both 2d and 3d game development, and is written in Java. In addition to Java, other JVM languages, such as Kotlin or Scala can be used to program libGDX games. At it’s core, libGDX uses LWJGL 3 to handle basic game functions such as graphics, input, and audio. LibGDX offers a large API to simplify game programming. LibGDX has an informative wiki on it’s Github page, and there are many tutorials on the internet.

Phaser

Phaser is an open source framework for developing HTML5 games for desktop and mobile. You can read more about it on their website here.

Minecraft Forge

If you've heard of Minecraft, chances are you've also heard of and used Forge. It allows you to mod your Minecraft game to make it do a bunch of cool stuff. Check it out in this article here.

Something a little different: Terasology

An open-source voxel sandbox game!

The Terasology project was born from a Minecraft-inspired tech demo and is becoming a stable platform for various types of gameplay settings in a voxel world. The creators and maintainers are a diverse mix of software developers, designers, game testers, graphic artists, and musicians. We encourage others to join!

Source: http://terasology.org/

Terasology is an open-source platform for gameplay of any kind in a voxel world. If you read that sentence attentively you can see I did not use the word ‘Game’. The reason behind that is the fact that Terasology itself is not a finished game! It’s merely a platform for you to modify yourself with your own code or pre-made modules. Do not worry though, there are loads of modules constantly developed by the multidisciplinary team.

The open-source spirit

Another really cool aspect of this game is fact that MovingBlocks (the organisation behind Terasology) participates in large events such as GCI (Google Code-In), GSOC (Google Summer of Code) and more! This makes the environment especially lively and it really empowers the community spirit. This is not some random product made by a greedy multinational, this is the work of a team. A team with a passion.

Want to contribute?

You too can contribute! Check out the repository here on GitHub and start hacking into the code! Make sure you format everything properly, use clear code and follow all of the repository-specific conventions! https://github.com/MovingBlocks/Terasology/wiki

More info on Game Development:

• What is Game Development?
• Learn Unreal Engine by coding 3 games (video)
• Ultimate beginner's guide to game dev in Unity
• Code a Super Mario Bros game to learn game dev (video)

If you're shopping around for a 2D game engine, you've undoubtedly come across Unity. Dipping your toe into Unity's editor can be overwhelming if you haven't had a good overview of where all of the tools live, particularly if it's also your first time using C# to write scripts.

In this article, I'll give you a tour of Unity's 2D features with an overview of what tools you'll need to create a platformer - or any kind of 2D game - and where to find them in the editor!

If you're considering Unity among other 2D game engines, take a look at this article for some options.

And if you'd prefer a visual tour of Unity, check out this video instead (28 minute watch):

In this overview, we'll be using the Warped City Unity Assets Pack by Ansimuz.

Overview

On first glance, Unity's editor will look familiar if you've used another "all-in-one" game engine, but if it's your initial entrée into game development, it might be overwhelming. Moreover, if you don't already have some experience working in C#, I highly recommend doing some tutorials using Microsoft's .NET or similar. Unity has a relatively steep learning curve, and if you can come to it with some basic proficiency with C#, you'll have an easier onboarding experience.

A lot of your time will be spent in the hierarchy (1), which allows you to keep track of all of your game objects in a given "scene," which is a specific portion of your game (like your "Start" menu or a particular game world in your platformer). With it, you can nest objects under others, manage your cameras and canvasses, and navigate through all of the game objects you've created.

You'll want to keep organized in your project tab (2), which acts as a file system that you can structure as you see fit. One best practice, for example, is to collect all of your assets in one folder, animations in another, scripts in yet another, and so forth. You can also click over to the console tab if you've instructed Unity to log stuff under circumstances that you dictate.

When clicking on a game object, either in the hierarchy or project tab, you'll be greeted with more details in the inspector (3). These details will depend on what kind of object you've clicked, and what you've attached to that game object. If you've created an empty game object, for example, there won't be much there. But if you've made a player character that has a a sprite attached, along with an animation controller, rigidbody2d to manage physics, collider2d to manage collisions, and a script to manage user input and interactivity, all of these will appear in the inspector for you to tinker with.

The rest of the real estate within the editor is taken up by the scene itself (4), which is where you'll build your game world, drop in objects and triggers, and go about your game designing. You can click over to the game tab to see what your game actually looks like when played (and play it by hitting the "play" button), or check out the Asset Store from the safety of your Unity client.

Where to Find Things Like the Animator

If you've read any of my writing about game engines, you've heard me whinge about Unity's 2D support being shoehorned into a 3D environment, and about how difficult it can be to locate the tools you need to get your work done.

Let's just say that some things are difficult to accomplish in Unity compared to other 2D game engines, but they're all still possible. If you're attempting to access the animator, for example, you'll need to select the Window > Animation > Animator, which is different from the location of the animations that you'll painstakingly create and save in your project tab.

Similarly, if you want to access Physics 2D settings, by all means, click on Edit > Project Settings, which are different from your personal preferences, located under Edit > Preferences. And if you're looking to tinker with builds, you'll want to go to File > Build Settings.

Similarly, if you just want to create a plain ol' game object, head to GameObject > Create Empty (or 2D Object if you know what you're looking for). If, conversely, you're trying to add a rigidbody to an existing game object, you'll need to go to Component > Physics 2D > Rigidbody 2D (or click "Add Component" in the inspector when you have the game object selected in the hierarchy).

I think it's clear by this point that finding the things that you'll need to get your work done can be complicated, nested as they are within different menus. It doesn't help that some of the tools themselves, such as the animator, are clunky compared to their counterparts in other 2D game engines, but once you get a handle on how they work, you'll find them to be perfectly serviceable.

Visual Studio and C# Scripting

Unity supports C# for writing scripts, and you can pair it with Visual Studio for a relatively painless integrated development environment.

Scripts are easily accessible through the editor, and you'll have to attach them to your game objects to make your game do pretty much anything. One fun feature is to declare a public variable in a script - say, an integer called "jumpSpeed" - and then attach that script to a game object in the inspector. You'll see that variable exposed in the Unity editor, and can change it on the fly while your game is running to see how your changes work in action.

Prefabs

Finally, Unity leverages the use of what they call "prefabs" to streamline your workflow. In essence, a prefab is a type of reusable object that you've created so that you can drop it in your game world again and again without the need for repeat customization.

Let's say that you create a monster in your top-down 2D adventure game as an empty game object, then attach a sprite, rigidbody2d, collider2d, animations, and a controller script. You can drag that monster into your project tab to make it a prefab, which allows you to use it again and again in your game world without having to go through the whole process every time.

Unity has several more features that support 2D game development, some of which I cover in the video above, and it would do to watch a few tutorials on specific aspects of the editor if you're considering using it for your next game. I'd particularly recommend brushing up on C# before tackling the editor itself, as doing so will provide for a more gentle learning curve.

Hope this overview is helpful for your next game!

If you enjoyed this article, please consider checking out my games and books, subscribing to my YouTube channel, or joining the Entromancy Discord.

M. S. Farzan, Ph.D. has written and worked for high-profile video game companies and editorial websites such as Electronic Arts, Perfect World Entertainment, Modus Games, and MMORPG.com, and has served as the Community Manager for games like Dungeons & Dragons Neverwinter and Mass Effect: Andromeda. He is the Creative Director and Lead Game Designer of Entromancy: A Cyberpunk Fantasy RPG and author of The Nightpath Trilogy. Find M. S. Farzan on Twitter @sominator.

A few weeks ago, I posted about my experience attempting to make a prototype in a bunch of different 2D game engines/frameworks to learn what makes them tick.

If you're shopping around for an engine for your next 2D game, this article will provide some things to consider that may help in your discernment process.

Do note that I'm not attempting to cover every 2D game engine out there; nor am I positioning one engine or framework over another. These recommendations are from my personal experience using different engines and frameworks for prototyping.

And if you'd prefer to watch rather than read, I've created a video version of this post (26 minute watch):

React

At first glance, you might be thinking, "React is a front end framework for making interactive websites. It's not a game engine!" And you'd be mostly correct.

React doesn't provide native support for game development basics, like, for example, 2D physics, but it does handle state extremely well. If you're already a JavaScript developer and willing to pair React with something like boardgame.io to make a simple 2D game, you could potentially get a prototype up and running pretty quickly.

For all other types of 2D games, you'll want to look elsewhere.

Unity

Unity has made itself ubiquitous in the 2D and 3D game development spaces. I'd position it as an excellent 3D game engine, and a serviceable 2D one.

The Unity editor is fairly complex, with a lot of nested menus that take some time to wrap your head around (check out this article for a tour of its 2D features). If you don't already have a background in C#, which Unity uses for scripting, you'll want to brush up on it prior to learning Unity, as doing so will ease your overall learning curve.

Unity also does a lot of things the "hard way" when it comes to 2D game development, which doesn't feel native compared to other game engines. Creating a 2D game world in Unity, for example, feels like you're shoehorning a 2D plane into a large 3D space, and things like animation and pixel perfection are more clunky than in other 2D-specific engines.

You can make any type of 2D game with Unity if you're willing to wrestle with the editor and underlying 3D idiosyncrasies. It has extensive community support, and you'll find that working with C# is a delight. Additionally, Unity's Asset Store has all kinds of art and templates for you to download and purchase, but buyer beware: you might spend as much time rewriting someone else's code to fit your project as you would just starting from scratch.

Unity is, in general, free to use, but pricing becomes more complex if you want to use everything it has to offer (see this page for more details).

Godot

Godot is a free and open source 2D and 3D game engine that supports GDScript, C#, and even C++ and Python if you're willing to do a lot of the heavy lifting to make them work. It supports a node-style workflow and is super lightweight.

If you're a) willing to invest in learning GDScript or b) already super good at C#, C++, or Python, you'll probably be fine in Godot, particularly if you like working with open source software. If not, you may get easily frustrated, as there isn't nearly as much support for C# or other languages as there is for GDScript. Still, Godot is a pleasant engine with which to work, and although it may not have the same pedigree and community support as something like Unity, if you're a self-starter you might feel well at home.

Construct 3

If you just want to make 2D games and don't care about programming language or subscription fees, you'll find Construct 3 to have everything you need to get a demo up and running, and quickly. All of your work will be done in a browser, using drag-and-drop tools (and custom JavaScript support if you need it).

Don't expect to have a meaningfully productive experience with Construct 3 for free, however. There's a simple demo that you can try out, but impactful game development with Construct 3 is locked behind a paywall, and a subscription at that.

Game Maker Studio 2

Game Maker Studio 2 has a user-friendly editor that supports a proprietary language called, appropriately, Game Maker Language (GML), along with visual scripting. It also has a lot of tutorials, great community support, and an asset store (which comes with the same caveats as Unity's, above).

The general workflow of Game Maker Studio 2 and doing things like animating sprites, setting up your game world, and so on, are straightforward and intuitive. GML might not be your cup of tea if you're coming from another, more widely-used programming language, and I would not recommend it as your first introduction to learning how to code. It employs some of the basic concepts of programming, but not important details such as coding best practices or how to write clean code.

Additionally, you can try Game Maker Studio 2 with a free 30-day trial, but will need to pay to continue to use it after that time.

Phaser 3

If you want to code everything and learn a lot about the JavaScript ecosystem while doing it, check out Phaser 3 (or wait for Phaser 4, which is on the way).

Phaser is a lightweight and powerful JavaScript framework for making 2D games. Whereas Phaser 2 was extremely well-documented and had excellent community support, Phaser 3 is quite the opposite. There's good official documentation and a bunch of examples (without much context around them, it must be said), and a dreadfully small amount of tutorials.

Expect to build everything yourself, but if you're looking for ES6 or TypeScript support, or if you really want to polish your skills as a JavaScript developer, you'll be able to go a long way with Phaser 3.

In the interest of fairness, I should mention a two other 2D game engines that have been recommended to me since I started writing on the topic: LÖVE 2D, which uses Lua, and MonoGame, which supports C#. I haven't used either of them (or others, such as PyGame), and can't speak to their usefulness, but they may be worth checking out.

Let me know which 2D game engine you wind up using, and why!

If you enjoyed this article, please consider checking out my games and books, subscribing to my YouTube channel, or joining the Entromancy Discord.

M. S. Farzan, Ph.D. has written and worked for high-profile video game companies and editorial websites such as Electronic Arts, Perfect World Entertainment, Modus Games, and MMORPG.com, and has served as the Community Manager for games like Dungeons & Dragons Neverwinter and Mass Effect: Andromeda. He is the Creative Director and Lead Game Designer of Entromancy: A Cyberpunk Fantasy RPG and author of The Nightpath Trilogy. Find M. S. Farzan on Twitter @sominator.