🎯 Goal

Design a modular, smooth, high-performance danmaku (弾幕 / bullet comment) system that:

• Works independently of the main game camera (via a dedicated Viewport)
• Supports multiple content types (text, image)
• Distributes danmaku across tracks evenly or with focused styles
• Dynamically calculates spacing and avoids overlapping

🎬 Step-by-Step Construction

Step 1: Start Simple

We began with a simple RichTextLabel-based danmaku node, moving from right to left:

Then in the C# code attached add the following.

public override void _Process(double delta) {
    Position -= new Vector2(Speed * (float)delta, 0);
    if (Position.X + GetWidth() < 0) QueueFree();
}

This worked fine until we realized something odd — the danmaku appeared offset and at (width, 0) it still appears to be from somewhere odd.

This danmaku not only is not playing from the correct location, it is also disappearing way too early. Why is that? It appears the player has a camera attached, and because of that, what we see on the screen does not map 1:1 to the real location. This is a problem.

Step 2: Decouple from Camera

To solve this, we moved the danmaku system to a separate Viewport layer (640x360), unaffected by the main camera. Now comments would always start from the right edge of the screen, regardless of world movement.

Question: How Danmaku is distributed on the screen?

Using this example concert video on Bilibili, we can see a bunch of tracks on the screen with rolling Danmaku from right to left.

We can view the entire Danmaku as distributed in invisible tracks on the screen, as shown below.

Step 3: Add Track Manager

Next, we introduced a DanmakuTrackManager to manage rows (or tracks) and ensure danmaku didn’t overlap.

public class DanmakuTrackManager
{
    private readonly List<List<DanmakuTrackEntry>> _tracks;
    private readonly Node _danmakuLayer;
    private readonly int _trackCount;
    private readonly float _trackHeight;
    private readonly float _screenWidth;
    private readonly float _spacing;

    public bool IsTrackAvailable(int trackIndex)
    {
        var track = _tracks[trackIndex];
        if (track.Count == 0) return true;

        var last = track[^1];
        float lastRight = last.Entry.Position.X + last.Entry.Call("GetWidth").AsSingle();
        return lastRight + 20f < _screenWidth;
    }
}

The system auto-calculates track count and spacing based on the size of a sample danmaku (like RichTextDanmakuLabel).

Step 4: Add Distributor

We then implemented IDanmakuTrackDistributor to control how tracks are assigned. Two distribution modes were added:

Even Distribute: Round-robin fill

Focus Few: Stack into fewer rows for visual intensity

public class EvenDistributor : IDanmakuTrackDistributor
{
    public int GetTrackIndex(int danmakuCount, int trackCount)
    {
        return danmakuCount % trackCount;
    }
}

This is a simple round-robin distributor that assigns danmaku to tracks evenly. But in reality, we need to access the track manager to check if the track is available.

Step 5: Add Queue System

Normally when a bunch of danmaku is added, we want to queue them up and then distribute them all at once. This is useful for when we want to add a bunch of danmaku at once, like when the game system is triggered to add a bunch of danmaku at once.

public partial class DanmakuSystemController : Node, ISystemModule
{
    private Queue<DanmakuQueueEntry> _danmakuQueue;
    private DanmakuTrackManager _trackManager;
    private double _lastSpawnTime = 0;

    public override void _Ready()
    {
        _danmakuQueue = new Queue<DanmakuQueueEntry>();
        _trackManager = new DanmakuTrackManager();
    }

    public void AddDanmaku(DanmakuQueueEntry entry)
    {
        _danmakuQueue.Enqueue(entry);
        ProcessQueue();
    }

    public override void _Process(double delta)
    {
      if (_danmakuQueue.Count == 0) return;
        // Peek queue and if time passed, spawn a danmaku
        if (Time.GetTicksMsec() > _lastSpawnTime + SpawnInterval)
        {
            // If the next track is available on the track manager
            if (_trackManager.HasTrackSpace())
            {
                var danmakuData = _danmakuQueue.Dequeue();
                _trackManager.AddDanmakuToTrack(danmakuData.Data);
                _lastSpawnTime = Time.GetTicksMsec();
            }
        }
    }
}

This code allows us to queue up danmaku and process them in the _Process method, checking if the track manager has space before spawning. If the track is available, it will dequeue the danmaku and add it to the track manager.

Step 5: Fix Overrun Issue

There is one issue, because the danmaku are using random speeds, faster danmaku would overtake slower ones in the same track, causing overlaps. The same effect is also shown on the Bilibili example above. The fix was to introduce a “speed clip” to ensure that the danmaku speed does not exceed the maximum speed of all danmakus in the track.

The following code is added to the DanmakuTrackManager to check if the track is available:

// Set initial speed, cap the speed to prevent overrun
danmakuData.Speed = Math.Max(GetMaxSpeedInTrack(trackIndex), danmakuData.Speed);

And then we need to implement the GetMaxSpeedInTrack method to get the maximum speed in the track.

private float GetMaxSpeedInTrack(int trackIndex)
{
    var track = _tracks[trackIndex];
    if (track.Count == 0) return 0;

    // Loop through track to get max speed
    return track.Max(entry => entry.Entry.Speed);
}

Step 6: Tieing It All Together

Now we talked about how to implement DanmakuTrackManager, IDanmakuTrackDistributor, DanmakuSystemController and the RichTextDanmakuLabel, we can now tie it all together in the main game scene.

Final Result

Conclusion

The danmaku system is now modular, efficient, and easy to extend. It supports different content types, distributes comments across tracks as needed, and manages spacing to prevent overlaps.

This approach keeps the codebase organized and maintainable, making it easier to add new features or tweak behavior later. Hopefully, this walkthrough gives you a solid starting point for building your own danmaku system in Godot 4 with C#. If you have questions or ideas, let me know—happy coding!

“Hello World.” — the very first line of code I ever wrote.
“GoodBye()” — the function I silently called when the system had finally worn me down.

👋 Who am I?

I’m a programmer.
And right now, I’m also a solo indie game developer.

This game is made by just one person — me.
Design, code, art, writing — everything built slowly in quiet hours fueled by frustration, burnout, and a tiny spark of something I thought I had lost.

I used to love writing code.
But somewhere along the way, I stopped writing for myself.

Now it’s for Jira, for managers, for interviewers, for KPI dashboards, for whatever counts as “professional growth.”

But I’ve realized something:
It’s not that I stopped loving programming.
It’s just been so long since I wrote anything for myself.

💬 Why make this game?

Because there are so many things I couldn’t say out loud.

“I’m trying my best, but I’m tired.”
“I don’t want to study for another interview.”
“My code is not for points or compliments in a PR comment — it’s because I used to believe code was a language of creation.”

This isn’t a story about success.
It’s a story about moving from Hello to GoodBye().

Not a failure — but an attempt to recover.

🎮 So what is this game?

It’s a pixel-art action platformer. It has a story.
The protagonist is a programmer.
That might be me. It might be you.

It’s not about saving the world. There’s no epic destiny.
It’s just someone breaking down inside a system,
and trying to find their way back to being human.

Or more precisely:

It’s a single function I wrote for myself —
one that never returns.

🛠 Current status

The game is still in development.
I’m working on the demo now.
There’s no release date. No trailer. No hype.

But I’ll keep updating this blog — with progress, breakdowns, and maybe a few breakthroughs.

Slowly, and stubbornly, I keep going.

If you’ve ever felt like you weren’t a person anymore —
just a process, a resource, a task in someone else’s system —

Then maybe this game is for you.

HelloWorld.GoodBye()
It’s not a project. It’s a message.
A quiet GoodBye() that never needs to explain itself.

Maybe it’s for you.
Or maybe it’s for the version of me that’s still trapped in that system.

“I understand.”
“You’re not broken.”
“You’re still here.”

What to Expect

• Game Development Logs: Progress updates, challenges, and milestones from our current projects.
• Technical Articles: Tutorials, code snippets, and discussions on tools and technologies we use.
• Behind the Scenes: Art, design, and music explorations that shape our games.

Stay tuned for more posts as we build, learn, and share together. Thanks for joining us on this adventure!

Follow us on Misskey for more updates and community discussions!