The challenge

Rumble Racer is an online multiplayer racing game for mobile that mixes Subway Surfers-style controls with popular arcade racing games. It’s a four-player racing game that ended up being very fun to play.

The challenge was to achieve a production-ready server infrastructure to host worldwide matches, keeping an eye on the infrastructure budget and providing high availability.

In the prototype stage, we choose Mirror as a networking engine for both matchmaking and gameplay. Mirror was a great match as it was open-source and had a great community on Discord, giving me the ability to extend the library as needed in the long run.

For production, using Mirror for matchmaking in the lobby has its flaws. Mirror runs Unity on a dedicated server and works perfectly, but as the matches add up it starts consuming CPU on the Linux box, requiring more instances and dividing players into batches per server. That limits matchmaking to the players connected to that server.

Also, due to the requirement to support worldwide players, and the low latency needed to keep a smooth real-time experience for everyone, regional servers were required.

Server architecture

So after some thought, I designed and implemented the server architecture as follows: a .NET lobby server in each region communicating using SignalR, and multiple Mirror servers connected to each lobby server. This provides a high-availability, scalable architecture to support as many players as required, with low latency and region-scoped matchmaking, while keeping Mirror for match simulation, where headless Unity shines.

Final game flow

The client connects to a master lobby server on start, downloading an updated list of servers. On the first connection, the servers are latency tested, choosing the fastest responder. Once connected, matchmaking takes place on the lobby server with all the players from that region, allowing a seamlessly integrated experience.

When the four players are ready, the lobby server acts as a load balancer, choosing a Mirror server to host the race and sending, via a REST API, the race info and the players’ info, then sharing that server’s details with each player so they can connect and start the race.

All servers are deployed on Linux machines using Docker containers, and we’re ready to add Kubernetes to the mix when traffic requires it, to provide real-time flexibility in the infrastructure.

You can find links to the store and more info about the game in the portfolio section.

In day-to-day development, I often want a quick first pass to identify the biggest contributors, spot suspicious spikes or allocations, and decide what to investigate next. That’s where AI can help, by turning a captured frame into a short list of hypotheses to validate in the Profiler. It’s not a replacement for profiling, but it can speed up the initial triage and help you decide where to look first.

The only issue is that when we save Profiler data, we get a binary file that LLMs can’t read directly.

To solve this, I’m using this tool unity-profiler-data-exporter (a fork from the tool from Stefano Di Palma I fixed to make it work with latest Unity versions) which lets you export a frame from the Profiler as a JSON file. With that, you can talk with your favorite LLM about what is happening in your game.

Workflow

Capture the problematic frame in the Unity Profiler.

Export that frame to JSON with unity-profiler-data-exporter.

Paste the JSON (or relevant parts) into your LLM along with a short question, for example: “What are the top contributors, and what should I check next?”

Validate the suggestions back in the Profiler and iterate.

What AI can help you spot quickly

Main thread bound frames vs render thread or GPU bound symptoms

GC allocations and spikes that hint at per-frame allocations

Expensive hotspots like Camera.Render, animation updates, physics steps, or Script.Update loops

Repeated calls or unusually deep stacks that point to a runaway system

Sudden spikes caused by asset loading, instantiation bursts, or expensive one-off work

Note on privacy

Profiler captures can contain project-specific details. If you’re working on proprietary code, consider sanitizing the data, removing identifiers, or using a local model before sharing it externally.

If you have comments, questions, or a way to improve it, shoot me an email!

When you are working to publish your app in other platforms than WebGL, or using old versions of Unity, you can just call Application.OpenUrl and get there.

This changed lately because 99% of the people (that’s a lot) wanted to open a new tab, so according to Unity’s documentation:

WebGL: From version 2019.4.25f1, 2020.3.5f1, 2021.1.2f1, and 2021.2.0a11, Application.OpenURL opens url in a new browser tab. In previous versions, Application.OpenURL opens url in the same browser tab, which terminates the running Unity application.

So from now on, Application.OpenUrl will open the url in a new tab, with an ugly warning from the browser saying a popup was blocked (but that is another story).

How to open a URL from WebGL in the same page?

So if you are between the 1% of the people who is actually looking to redirect the page to another location, this is a possible solution.

We will interact with the scripts in the browser to perform an old good javascript redirect. For that we will have to create a jslib file as is explained in the documentation here.

First, you will have to create a folder Plugins under your Assets folder, and there place a text file with the extension “.jslib”. Then open this file and write the following code in it:

var RedirectPage = {
    openUrl: function(link)
    {
        window.location.href = UTF8ToString(link);
    }
};

mergeInto(LibraryManager.library, RedirectPage);

And then from your C# code you can use it like this:

using System.Runtime.InteropServices;

public class ClickHandler : MonoBehaviour
{
    [SerializeField] string url;

    private void OnMouseDown()
    {
#if !UNITY_EDITOR
        openUrl(url);
#endif
    }

    [DllImport("__Internal")]
    private static extern void openUrl(string url);
}

And that’s it, you can replace the OnMouseDown with any method you need and is ready to go. Hope it helps!

If you have a comment, a question or a way to improve it, shoot me an email!

Code in the parent class

In the parent class, when you specify the original methods that you intend to extend in the child, you have to specify the keyword “virtual” in the declaration, this way the compiler will know it can be later on overriden in a derived class. So let’s supouse we want Update() and Start() working in our child, the code would be something like this.

    public class ParentClass : MonoBehaviour
    {
        protected virtual void Start()
        {
            //configuration stuff
        }
        protected virtual void Update()
        {
            //things to do every frame
        }
    }

That way when you write the methods in the child, the compiler will know you want it to override those.

Code in the child

In the child we will simply write the override keyword in the declaration to let the compiler know we want to do so, and if we want to run the code in the parent, just call the original method using base.Method(), or not if you just want to completely override it.

public class ChildClass: ParentClass
{
    protected override void Start()
    {
        base.Start(); //you can run parent's code at any moment you need to
        //configuration stuff just in the child
    }
    protected override void Update()
    {
        base.Update();
        //things to do every frame just in the child
    }
}

Of course there are tons of scenarios where a different approach would be better used, but in my experience this work for most cases where you need to extend the MonoBehaviour functionality.

If you have a comment, a question or a way to improve it, shoot me an email!

What is the difference?

While Raycast will send a vector in a given direction and detect what colliders are on the way, OverlapPoint simply uses a point in the screen and checks if there is a collider that overlaps that point.

In terms of performance, even while in 2D may not be that expensive, the team at Unity recommends using the least ammount of raycasts as possible in their Physics Best Practices document.

So, is it the same?

No, it is not. A raycast can be used for many things as you will not always be sending it from the screen to the plane, BUT if you want to specifically detect objects being under the mouse or tap position in the screen, I’m confident that with few tweaks you can change the implementation from one to another with no drawbacks.

The Code

So the code to detect our object on click might be something like this:

if (Input.GetMouseButtonDown(0))
{
    Vector2 touchPosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
    Collider2D collider = Physics2D.OverlapPoint(touchPosition);
    GameObject gameObjectClicked = collider.gameObject;
    //do what you need to do
}

If you have a comment, a question or a way to improve it, shoot me an email!

What are GUIDs?

In Unity, GUIDs are unique identifiers that are automatically assigned by the system to each file and folder. Those ids are written in each .meta file that Unity creates automatically for each file we add to our project.

Why you should care about GUIDs?

Let’s say you have scripts, sprites, prefabs, or any other Unity component that are beign used in entities in your scene, for example, you have a Game Object that is using an image asociated to the SpriteRenderer component, and a C# script in that same object. That object under the hood will look for the asset by GUID, so if you import that scene to another project, and Unity by any chance change the GUID because the original ones are in use, those references will be broken, or even worst, pointing to a different asset making it more complicated to identify.

So, what can I do about it?

Long story short, I was manually replacing GUIDs with Visual Studio Code in my project when I found this package from Jeff Jadulco that you can add to your project before the merge, and change all the GUIDs and references straight from the Unity’s UI.

You can add the package from the following git url in the package manager:

https://github.com/jeffjadulco/unity-guid-regenerator.git

After that, right click in your project files and just select “Regenerate GUIDS”.

One thing to take into account, is that in order for this to work (either using the Jeff’s package or doing it manually), you need to have your assets serialized. This is done in Project Settings > Editor > Asset Serialization > Mode: “Force Text”.

Thank you Jeff!

You can get the package here and it’s well documented on how it works and how to use it.

If you have a comment, a question or a way to improve it, shoot me an email!

using UnityEngine;

public class CameraControllerBuilder : CameraController
{
    [SerializeField] private float topEdge;
    [SerializeField] private float bottomEdge;
    [SerializeField] private float leftEdge;
    [SerializeField] private float rightEdge;

    private bool isDragging = false;
    private Vector3 startCameraPosition;
    private Vector3 startMousePosition;
    private Vector3 newMousePosition;
    new void Start()
    {
        base.Start();   
    }

    void Update()
    {
        if (Input.GetMouseButton(1) || (Input.touchCount == 2))
        {
            newMousePosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
            if (isDragging)
            {
                transform.position = startCameraPosition + startMousePosition - newMousePosition;
                if (transform.position.x < leftEdge || transform.position.x > rightEdge)
                    transform.position = new Vector3(startCameraPosition.x, transform.position.y, transform.position.z);
                if (transform.position.y < bottomEdge || transform.position.y > topEdge)
                    transform.position = new Vector3(transform.position.x, startCameraPosition.y, transform.position.z);
            }
            else
                isDragging = true;
            SavePositions();
        }
        else if(isDragging)
        {
            isDragging = false;
        }
    }

    private void SavePositions()
    {
        startCameraPosition = transform.position;
        startMousePosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
    }
}

If you have a comment, a question or a way to improve it, shoot me an email!