Modernizing the Command Interface

Greetings, Commanders.

This transmission is going to be a bit different. Usually, I talk about what you'll be doing in the game—commanding fleets, designing ships, or managing corporate diplomacy. Today, I want to talk about how you'll be doing it, and the massive overhaul the user interface has undergone in the past few weeks.

Picture this: you are managing three colonies simultaneously. You have a fleet en route to an intercept, your diplomacy screen is blinking with an incoming proposal, and you need to adjust the power grid on your primary mining facility before it collapses.

If the UI lags, or if information doesn't update in real-time, the simulation breaks. You stop feeling like a corporate commander and start feeling like a player fighting the controls.

The MVVM Refactor

To ensure the interface can handle the sheer volume of data Fragile Allegiance throws at you, we recently gutted the old UI systems and transitioned entirely to an MVVM (Model-View-ViewModel) architecture using Unity's UI Toolkit and VisualTreeAssets.

What does that mean in non-developer terms? It means the visual elements you see on screen (the Views) are now completely decoupled from the underlying game simulation (the Models). They talk to each other through a middleman (the ViewModels).

When a ship in your fleet takes damage, the game logic doesn't have to manually find the health bar on your screen and tell it to shrink. Instead, the health bar is "listening" to an Observable<T> property on the ViewModel. The moment the ship's armor value changes in the simulation, the Observable fires, and the UI updates instantly and automatically via the Subscribe() callback.

Shared Top UI and Kahn's Algorithm

This MVVM architecture allowed us to implement the new Shared Top UI. We use a ServiceLocator pattern to ensure global HUD widgets—like your credit balance, the current date, and notifications—are accessible from anywhere.

To ensure everything boots up correctly, the UI services (and all other game systems) register themselves on startup, and we use Kahn's Algorithm (a topological sort) to resolve their dependencies. If the BudgetUI needs the Players and GameDate systems to exist before it can draw, the topological sort guarantees those systems are fully initialized first.

Because of this, no matter what screen you are on—whether you're zoomed in on a colony's surface, examining the sector map, or custom-designing a destroyer in the shipyard—your critical information is always accessible and never crashes due to a missing dependency.

We've also added a robust notification system. When a neutral faction contacts you, or an AI fleet changes its behavior, a dedicated notification element slides into view. Because of the MVVM structure, these notifications are lightweight and don't interrupt your current actions.

Why Rebuild It Now?

Rebuilding a UI architecture mid-development is painful. But it was necessary. The original games relied heavily on nested menus and static screens. To bring this remake to modern standards, we need dynamic overlays, real-time data binding, and a clean separation of concerns.

This refactor means fewer bugs when new features are added, and a much smoother, more responsive command experience for you when the game launches.

What's Next

With the UI architecture solidified, we are moving back to the tactical layer. The AI fleet behavior is getting an upgrade to make them more cunning in sector-wide maneuvers.

Signing out,

  • Jari