Ernest.dev

  • [AoNW] The Refactor So Far: One Turn Pipeline and Shared Game Rules

    In the previous update, the legacy map adapter was gone and DomainState had become a real part of the application. Most of turn finalization already used the new state, but one old section remained in the middle: the economy phase still converted the canonical snapshot to PersistentGameState, processed the turn, and converted the result back.

    That legacy island is now gone.

    The complete simultaneous turn now stays on canonical or persistence-neutral types, and the old persistent implementation of simultaneous finalization has been removed. At the same time, the same migration pattern is spreading through normal player commands, where local play, the multiplayer server, and AI previously had separate versions of similar rules.

    (more…)

  • [AoNW] My Perspective on Using Language Models in Indie Game Development

    When I showed my game to a wider audience for the first time, many people focused on the visuals and called the game “AI slop”. This was mostly a reaction to the generated maps, units, icons, and other assets that were visible in screenshots.

    I understand where this reaction came from. A screenshot shows the map before it shows the game rules, multiplayer synchronization, AI simulations, save migrations, tests, or the architecture behind the project. It presents the weakest part of the current build first.

    I already explained my perspective in an earlier post. I have always treated the existing assets as visual boilerplate for future dedicated assets, not as the final art direction. They allowed me to focus on mechanics, release a working version, and collect feedback without waiting until every part of the game looked finished.

    Since then, I have not become a graphic artist, and I did not suddenly wake up with a talent for painting terrain. But still I can build a process that gives me more control over the result.

    (more…)

  • [AoNW] The Refactor So Far: The Map Adapter Is Gone and DomainState Is Real

    In the original refactor post, I described the target architecture and a plan for reaching it without rewriting the whole game. In the previous progress update, the project already had stronger quality gates and one indexed map model, but the migration was not complete because two production conversions still existed, the legacy map adapter was still alive, and DomainState was mostly a target shown on a diagram rather than a type used by real gameplay paths.

    That is no longer the current shape of the project. The last map adapter has been deleted, the local reducer uses read-only map contracts, several old state models now own their collections instead of borrowing mutable lists and maps, and a real DomainState exists together with a canonical snapshot that separates game rules, match session data, metadata, persisted interaction, and the event offset. Turn combat and turn movement now run directly on this canonical state, while only the economy phase still uses the old persistent model.

    (more…)

  • [AoNW] The Refactor So Far: One Map, Better Gates, Less Drift

    In the previous post, I described a plan to refactor Age of New Worlds without rewriting it.

    The plan looked clean on paper.

    Then the real work started.

    The goal was not to move files around or rename a few classes. The goal was to remove duplicate paths while keeping the game working after every step.

    The first safety work is now complete. Most of the new quality gates are running. The map migration is far advanced. Some real inconsistencies were found and fixed along the way.

    (more…)

  • [AoNW] Refactoring a Growing Flutter 4X Game Without Rewriting It

    When I wrote the first article about Age of New Worlds, the basic game loop was already working.

    I could explore a hex map, found cities, move units, manage production, research technologies, improve terrain, end turns, and save the game. Flutter and Flame had already proved they could handle a 4X game. The new question was whether I could keep adding features without making the code harder to change every time.

    (more…)

  • [AoNW] Shipping a Flutter Game to Multiple Platforms

    Age of New Worlds is now available outside my development machine. The current release covers iOS, macOS, Windows, Linux, and Android, with a web demo, direct downloads, store versions, and source code available publicly. That was the original technical goal: build one game codebase and make it run on real platforms.

    Where To Play

    (more…)

  • [AoNW] Adding Gamepad Support to a Flutter 4X Game

    Age of New Worlds started as a mobile-first game.

    That shaped a lot of early decisions. The map had to work with touch. The HUD had to survive small screens. Panels had to slide in and out without burying the world. Most interactions were built around taps, long presses, drags, and responsive layouts.

    For a while, that was enough.

    Then the game started growing toward more platforms: web, desktop, Steam, and eventually devices like the Steam Deck. At that point controller support stopped being a nice extra and became part of the shape of the game.

    (more…)

  • [Peryhelium] Moving a 4X Game Domain From AoNW to Unity

    While waiting for Age of New Worlds to move through the publishing path for iOS, Steam, and Android, I tried a small experiment.

    This time in Unity.

    Not as a replacement for AoNW. More as a question:

    What happens if I take some of the mechanics and architecture from AoNW, move them into a 3D engine, and let the concept grow in a different direction?

    A few hours later, I had the first slice of Peryhelium: a space 4X prototype about colonizing the Solar System, starting with the Moon, previewing locked planets, and rendering spherical hex maps with real planetary textures.

    (more…)

  • [AoNW] Refactoring Multiplayer to Serverpod

    The first multiplayer implementation in Age of New Worlds was not a mistake.

    It was a proof of concepts.

    I needed to learn where the hard parts really were: command dispatch, reconnects, snapshots, event offsets, fog of war, match lobbies, AI turns, and the strange little edge cases that only appear when a turn-based game is running across two devices instead of one.

    That version used a custom Dart server, HTTP routes, WebSockets, JWT handling, PostgreSQL repositories, and a lot of glue code.

    It worked well enough to answer the most important question:

    Can this game have multiplayer at all?

    The answer was yes.

    But once the concept was proven, the shape of the problem changed.

    Now I do not need “a server that works”. I need a server architecture that is boring in the right places, strict in the important places, and easy to evolve without leaving a trail of networking code across the Flutter app.

    That is why I started moving multiplayer to Serverpod.

    (more…)

  • [AoNW] Turning Game History Into Something You Can Actually Use

    A strategy game is not only about making decisions.

    It is also about understanding them later.

    In Age of New Worlds, a turn can contain many tiny things: a scout discovers a new civilization, a city finishes production, a unit moves through fog of war, diplomacy changes slightly, a battle resolves, research progresses, and the player probably notices only half of it while thinking about the next move.

    (more…)