Lunastadt Devlog 5-17-2026 — The Week I Stopped Everything and Just Fixed Stuff
https://www.youtube.com/watch?v=aMHZmXSeN4I
Lunastadt Devlog
Posted May 17, 2026
Tags: Lunastadt, gamedev, indiedev, RTS, strategy game, playtesting, game balance, game development
There comes a point in game development where adding more features is no longer the most important thing.
More units are exciting.
More explosions look great in videos.
More systems make the game sound bigger on paper.
But none of that matters if the game does not feel good to play.
That has been the main focus of Lunastadt recently: gameplay testing, balancing, mechanics, performance, and feel. Not just asking, “Does this system technically work?” but asking the harder question:
Is this actually fun?
Because before Lunastadt can be released, everything needs to feel right. The game needs to be playable, understandable, responsive, and enjoyable. It cannot just be a pile of impressive systems. It has to become a real game.
Moving From “It Works” to “It Feels Good”
Lunastadt has grown into a fairly complex strategy game.
There are cities, military bases, tanks, fighters, bombers, anti-air batteries, police units, supply systems, city capture mechanics, factories, front lines, procedural destruction, and an in-game command interface powered by local AI.
That is a lot of moving parts.
For a while, the focus was simply getting those systems into the game. Getting tanks to move. Getting fighters to attack. Getting cities to simulate population, infrastructure, collapse, and occupation. Getting the enemy commander to make decisions. Getting the battlefield to actually function at the scale of a continental invasion.
But once those systems exist, the next stage begins.
That stage is refinement.
This is where the game stops being a prototype full of cool ideas and starts becoming something that feels intentional. Something where the player gives an order and the game responds clearly. Something where combat makes sense. Something where the enemy is dangerous but not impossible. Something where victory feels earned instead of random.
That is the stage I am in now.
Playtesting Has Become the Main Development Tool
A lot of recent development has been hands-on gameplay testing.
Not just running the game for a few minutes to see if it crashes, but actually playing it, watching the flow of the invasion, observing what the AI does, seeing where units go, checking whether the player has enough tools to fight back, and looking for the moments where the game stops being fun.
That last part matters.
Sometimes a system can be technically correct and still not feel good.
A tank might be able to attack across the map, but should it?
A bomber might be powerful, but is it too powerful?
An enemy invasion might be scary, but is it so strong that the player feels helpless?
A front line might be accurate, but does it visually communicate what is happening?
A city might collapse correctly, but does the player understand why?
These are not just programming questions. They are design questions.
And they only show up when you actually play the game.
Balancing the Lunastadt Invasion
One of the biggest things I have been working on is balance.
Right now, Lunastadt is meant to feel overwhelming. That is part of the concept. This is an invasion from the Moon by a technologically superior enemy force. The player should feel pressure. The map should feel dangerous. The enemy should not feel passive.
But there is a fine line between “powerful enemy” and “the player has no chance.”
Recently, the Lunastadt forces have been too strong. In some tests, they were nearly impossible to defeat, even with extreme measures. That tells me the concept is working — the enemy feels terrifying — but the game still needs to be playable.
The player needs room to recover.
The player needs meaningful choices.
The player needs a chance to slow the invasion down.
The player needs victories that matter.
So the balancing work has been about finding that sweet spot: Lunastadt should feel like a nightmare rolling across the United States, but not like an automatic loss.
That means adjusting combat strength, unit behavior, city capture speed, defensive response, aircraft effectiveness, anti-air systems, police resistance, and the pacing of the enemy commander’s expansion.
The goal is not to make the game easy.
The goal is to make it fair, readable, and fun.
Mechanics Need to Support the Fantasy
Lunastadt is not just a strategy game about units moving around a map. It has a very specific fantasy:
You are watching a massive alternate-history invasion unfold across the United States, and you are trying to command the response in real time.
That means the mechanics have to sell that idea.
Cities should not feel like static dots on a map. They need to feel like places under threat. That is why police units, local resistance, population systems, city damage, collapse mechanics, and occupation systems matter.
Military bases should not just be labels. They need to matter strategically. Capturing Wright-Patterson Air Force Base, for example, should feel like a major turning point because it gives the invasion access to air operations and regional control.
The front line should not just be a debug overlay. It needs to feel like a living war map, showing the pressure of Lunastadt’s advance and the shrinking space the player has left to defend.
Every mechanic has to support the larger feeling of the game.
The invasion should feel alive.
The battlefield should feel reactive.
The player’s decisions should feel consequential.
That is the standard I am working toward.
Fixing the Things Players May Never Notice
A lot of the recent work has been invisible.
That is one of the strange things about game development. Some of the most important improvements are the ones players will never directly point out.
If tanks stop behaving strangely, players may not say, “Great job fixing autonomous engagement ranges.” They will just feel like the tanks are more reliable.
If the game stops wasting CPU on unnecessary lookups, players may not know why the frame rate feels smoother. They will just feel that the game plays better.
If a command system becomes more responsive, players may not notice the architecture behind it. They will just trust the interface more.
That invisible work matters.
Recently, I have been fixing systems that were doing too much work behind the scenes. Trade systems, explosions, unit searches, city simulation, movement logic, selection behavior, and AI commands all need to run efficiently because Lunastadt is trying to simulate a very large battlefield.
When a game has hundreds or thousands of entities, small inefficiencies become major problems.
So part of making Lunastadt fun is making Lunastadt faster.
Performance is not separate from gameplay.
Performance is gameplay.
If the game slows down, the player feels it. If the game stutters, the illusion breaks. If commands lag, strategy becomes frustrating. For a large-scale RTS, smooth performance is part of the design.
Making Units Behave Correctly
Another major focus has been unit behavior.
In a game like Lunastadt, units need to feel dependable. When the player selects a tank and gives it an order, that tank needs to do what the player expects. When fighters patrol, they need to attack the right targets. When anti-air batteries engage, they need to recognize friend from foe. When police defend a city, they need to behave like local defenders rather than full military units.
These details matter because player trust is everything.
If the player cannot trust the units, the game feels broken.
Recently, I have been working through issues like tanks engaging from too far away, units moving incorrectly, enemy forces being selectable when they should not be, friendly-fire problems, and behavior that looked fine in code but felt wrong in actual gameplay.
That is the reality of development: sometimes the system technically does what you told it to do, and then you realize you told it the wrong thing.
The fix is not always dramatic. Sometimes it is a range value. Sometimes it is a faction check. Sometimes it is a movement state being canceled by another script. Sometimes it is a system that needs to ask, “Who owns this unit?” before allowing the player to control it.
But all of those details build the feel of the game.
The Importance of Game Feel in a Strategy Game
People often talk about “game feel” in action games — how a jump feels, how a weapon feels, how movement feels.
But strategy games need game feel too.
In Lunastadt, game feel means:
Orders should feel immediate.
Units should respond clearly.
The map should communicate danger.
The front line should be readable.
Combat should feel powerful but understandable.
The enemy should feel intelligent without feeling unfair.
The player should always understand what tools they have.
The game should feel large without feeling confusing.
That is what I am trying to tune now.
The game already has the bones of something big. The question now is how to make every part of it feel good in the player’s hands.
Everything Needs to Be Right Before Release
I do not want to rush Lunastadt out just because it looks interesting.
A game can have a great concept and still fail if the moment-to-moment experience is not there. That is why this stage matters so much.
Before release, the game needs to be stable.
It needs to be optimized.
It needs to be balanced.
It needs to be readable.
It needs to be fun.
The player should not have to fight the interface.
The player should not have to guess why something happened.
The player should not feel like the enemy wins because the game is unfair.
The player should not feel like systems are working against them.
The goal is for Lunastadt to feel like a living battlefield, but also like a playable game.
That means testing, adjusting, breaking things, fixing them, testing again, and being honest about what is not working yet.
Where the Game Is Headed
Right now, Lunastadt is moving from prototype chaos into real gameplay shape.
The big systems are there. The war is happening. The cities can fall. The front line can move. The enemy can advance. The player can respond.
Now the work is about making all of that feel better.
That means continuing to tune the enemy commander, improving the pacing of the invasion, making city defense more meaningful, reducing performance bottlenecks, improving unit control, and making sure every mechanic supports the core experience.
This is the part of development where the game starts to become itself.
Not just a tech demo.
Not just a map full of systems.
Not just an idea.
A game.
And that is the goal: to make Lunastadt not only impressive, but playable, balanced, and fun.
Because everything needs to be right before release.
— Sean
Black Sail Studio
#devlog #GameDevelopment #gamedev #indiedev #Lunastadt #optimization #technology #unity
sayzard
Black Sail Studio
jimfl
Hacker News
Lobsters
Zlormack
arya dradjica (find me at RustWeek!!!)