Vorgar did not begin as a finished design document. It began as a rough instinct: I wanted a strategy game that would be simple enough to understand quickly, but deep enough to play again and again.
That sounds clean when written in one sentence. In practice, it raised a lot of questions. What should the player actually do each turn? How much should the game explain? How many systems are enough before the design becomes heavy? What makes a match worth replaying?
For the first few days, the most useful tool was not a code editor. It was ChatGPT on a paid plan, used as a planning partner. I brought messy thoughts, doubts and half-formed rules into long conversations, then kept pushing until the idea became testable.
The useful part was not getting one perfect answer. It was having a place to ask the next better question.
Testing the idea before building it
I used those conversations to compare similar apps, check possible solutions, think through tools, and simulate how the game might feel in motion. If a player has one army here and a city there, what creates pressure? If combat is too complex, does the game slow down? If the map changes, does the match still make sense?
That kind of back-and-forth helped separate the attractive ideas from the playable ones. Some mechanics sounded interesting until they were placed inside an actual turn. Some rules became stronger when they were made simpler. Some problems only appeared when I tried to imagine the tenth move, not the first.
Slowly, the core shape became clearer: hexes, armies, cities, gold mines, gold, borders and pressure. A player should be able to look at the board and understand why a place matters. Losing cities should hurt. Expanding should feel tempting. The rules should stay readable.
Simple rules, more room to return
The breakthrough after roughly three days was not a giant list of features. It was the opposite. Vorgar started making sense when the design became smaller and sharper.
I did not want a strategy game that required a huge unit roster before it became interesting. I wanted a game where the map, city positions, resources and player decisions could carry the tension. Random city spawns and different map types became important because they give each match a different shape without forcing the rules to become complicated.
That is still one of the main goals: a simple strategy system that can scale. More maps, online opponents, new modes and future roadmap ideas can expand the game, but the center should remain easy to read.
Mockups made the direction visible
Once the skeleton was there, I used AI-assisted mockups to make the possible game more visible. Those images were not final art and they were not a promise. They were a way to look at the idea from a different angle.
Seeing rough screens helped me ask better questions about the player experience. What needs to be visible all the time? Where should actions live? How much information belongs on the board, and how much belongs in panels? A mockup can be wrong and still be useful if it helps expose the next decision.
That was the pattern that kept working: question, simplify, test the idea, make it visible, then ask again.
The first clear step
After those first conversations, Vorgar finally had something I could build toward. Not the final version, not every planned feature, but a clear first target: a playable turn-based hex strategy game with simple rules, meaningful cities, resource pressure and enough variation to return to it.
That clarity mattered because spare time is limited. When development happens around work, family and normal life, the project needs a direction that can survive short sessions. A clear skeleton makes every small step easier to choose.
The next challenge was turning that plan into real Unity code, real screens and eventually a live Android build. That part became its own lesson, with different tools, different limits and a lot more practical friction.