Moongate V2 Dev Log #5: GM Tools, Template Tooling, ModernUO Imports, and Smarter Guards
Last week was about making core gameplay real.
Combat, corpses, loot, scripted NPCs, and the first serious plugin direction all crossed an important threshold. Moongate stopped feeling like a server with promising systems and started feeling more like a world with actual runtime behavior.
This week built on that, but from a different angle.
The work shifted toward authoring, operability, and scale. I spent a lot of time making the server easier to run, easier to extend, easier to feed with content, and easier to manage in-game once the world is actually live. That meant better GM tooling, a proper template validation workflow, a stronger plugin story, a much deeper ModernUO import pipeline, a cleaner AI shape, and guards that finally behave like something closer to guards instead of generic combat actors.
It was one of those weeks where the project became more practical from several directions at once.
The GM workflow became much more real
One of the most visible additions this week is a proper GM menu.
Until now, a lot of admin and world-building work still felt too close to raw commands. That is fine early on, but once you start actually managing content and staff workflows, you want a more structured control surface. So I added a new GM menu with a sidebar layout, better search and target plumbing, reusable gump layout helpers, and dedicated operational tabs.
That includes a spawn flow and a broadcast flow directly inside the menu. The spawn side is especially important because it starts turning staff actions into a guided workflow instead of a memory test. The broadcast side is smaller, but operationally useful in a very immediate way: if the server needs to say something globally, there is now a direct place to do it from the GM interface.
What I like about this addition is that it is not just a prettier front-end for old commands. It is a shift in how the project thinks about operations. Moongate needs internal tools that feel intentional, not just a collection of escape hatches. This week pushed that in the right direction.
Content authoring got better tooling on both sides
Another major theme this week was content tooling.
I added moongate-template, a dedicated validator for template data. That matters because the template layer is becoming one of the most important authoring surfaces in the project, and once that happens, invalid content has to fail fast and clearly. A broken template should not be something you discover later through weird runtime behavior. It should tell you up front that a loot entry points to a missing item, that a mobile references a missing pack, or that a structure is no longer valid against the current schema.
This is one of those improvements that seems modest on paper but changes the day-to-day ergonomics of the whole project. As the amount of data grows, validation stops being optional polish and starts being a core development tool.
I also improved the output and packaging around that tool so it behaves more like a serious part of the workflow and less like an internal side utility. It now has clearer versioning and more self-explanatory output when you run a validation pass.
On the extension side, I also added a dotnet new template for Moongate plugins, together with the plugin structure and surrounding SDK work needed to make that template meaningful. I care a lot about this because I do not want "plugin support" to exist only as an architectural idea. I want a developer to be able to start from a real plugin skeleton instead of a blank class library and a vague sense of how things are supposed to fit together.
That makes the project more than just a game server codebase. It makes it more like a platform with an opinionated extension path.
The ModernUO import pipeline became much deeper
This was also a big week for content import work.
I pushed the ModernUO pipeline a lot further: more static item coverage, creature and container loot templates, reusable base loot packs, support items, generated NPC templates, mobile variants, and a Python converter flow that can bring over much more of the source data without turning everything into hand-ported content.
That sounds like a lot of separate changes, but it really belongs to one story.
I do not want Moongate content growth to depend on slow, error-prone manual copying. If there is useful content structure already present in ModernUO, the right long-term move is to build import paths, normalize them into Moongate's own data model, and then validate the result properly. That is how content authoring scales without becoming chaos.
This week made that pipeline significantly more trustworthy. Loot packs and item dependencies got cleaner. The NPC converter got more accurate. Template references got more robust. Hot reload also became more centralized, which matters once content iteration becomes a normal loop rather than an occasional maintenance task.
What I find encouraging here is that Moongate is no longer just borrowing content ideas. It is developing a repeatable import-and-normalize pipeline.
That is a much healthier direction.
AI got a clearer shape instead of accumulating special cases
I also spent a lot of time cleaning up the AI side of the runtime.
One of the bigger design shifts was moving mobile templates toward a canonical ai block instead of leaning on the older loose brain shape. That gave the imported and native content a more coherent structure for things like AI family, targeting behavior, and range metadata. At the same time, I continued the Lua-side work by normalizing the main brain tick to on_think and cleaning up the AI runtime naming so the Lua layer feels like Moongate's own runtime instead of a collection of half-translated pieces.
This week also included the first serious pass on ModernUO-style AI brains in Lua. The important part is not just that there are more AI scripts now. The important part is that the runtime is becoming easier to reason about. The data model is clearer, the naming is clearer, the Lua bridge is cleaner, and the whole system is less dependent on ad hoc compatibility shims.
That kind of cleanup matters a lot in scripting-heavy systems. If you let naming, shape, and runtime conventions drift for too long, the scripting layer becomes one of the hardest parts of the codebase to evolve.
I am trying to avoid that while it is still easy to make the structure honest.
Guards are now much closer to actual world systems
The guard work this week deserves its own section because it stopped being cosmetic.
I had already started moving guards away from obviously fake behavior, but this week pushed them much further. I added a dedicated guards scripting module, ported more of the guard policy into Lua, improved the runtime contract around focus and reactions, added optional random patrol roaming, and then enabled patrol by default so city guards no longer feel nailed to the floor.
There were also a few follow-up fixes that made a real difference: anchoring patrol correctly to home, recovering properly when a guard crosses a boundary, cleaning up runtime naming, and fixing the kind of scripting bugs that only show up once the behavior is actually live and no longer theoretical.
This was important to me because guards are one of those systems that say a lot about the maturity of a shard. If guards feel dumb, static, or brittle, players notice immediately even if they cannot explain exactly why. If they greet, react, hold space properly, and roam in a believable way, the world feels more supervised and more inhabited.
That is exactly the sort of "small on paper, large in effect" system I want to keep improving.
There were also a lot of quality-of-life improvements around the edges
A week like this also accumulates a lot of supporting work that is easy to overlook if you only talk about the headline features.
I shipped the 1.1.0 release, refreshed parts of the docs, updated compatible UI dependencies, cleaned out obsolete Lua IL suppression noise that no longer made sense after dropping the old AOT path, improved the enhanced client handshake and character profile flow, and kept tightening the operational side of the repo.
None of those things are as eye-catching as a new menu or a smarter guard, but they matter because they reduce drag. They make the project easier to build, easier to validate, easier to explain, and easier to keep moving forward without accumulating unnecessary friction.
I tend to think that this is where a lot of project quality really comes from. Not from one giant feature, but from a lot of small decisions that keep the daily working surface sane.
Important points
The short version of this week is:
- the GM workflow is no longer just commands; it has a real in-game menu now
moongate-templategives the data layer a proper validation tool- Moongate now has a
dotnet newplugin template with a cleaner plugin structure - the ModernUO import path got much stronger for items, loot, NPCs, and templates
- the AI runtime moved toward a more coherent canonical
aimodel - guards got a much more believable Lua-driven behavior model, including patrol roaming
- the project shipped
1.1.0while also getting cleaner docs, cleaner tooling, and less internal friction
I like weeks like this because they improve both the product and the development surface at the same time.
Moongate is still far from finished, but it is getting easier to imagine what operating, extending, and authoring for it will feel like at a larger scale. That is a good sign. A lot of game server work can look productive while quietly increasing complexity. This week felt better than that. It made the project more capable, but it also made it easier to hold together.