Hex Strategy Map — Turn-Based Strategy Toolkit for Godot 4.6+

If you tried the free version, you already have the foundation: hex grid, pathfinding, fog of war, rendering, camera. That's the boring half — the part where it draws nicely and units can find their way around.

Hex Strategy Map Pro is the other half — the part where it starts to feel like an actual strategy game. Units that move and exhaust their points. Turns that cycle through players and phases. Combat that resolves with your rules, not someone else's. Maps you paint visually in the Godot editor. A working 2-player skirmish you can pull apart line by line.

Pro is for the moment you realize that "just a small combat function" has somehow become twelve files, the turn system has bugs you can't reproduce, and the actual game design is still a Notion doc you haven't touched in a week. You've already accepted you need a strategy toolkit. This is the rest of it.

Built from a real project

I'm developing a game with a strategic exploration phase inspired by Heroes of Might and Magic. After three iterations of that phase, I noticed something: most of what I'd written wasn't actually specific to my game. The terrain costs were constants, but they didn't have to be. The visibility formula was hardcoded, but if I passed it in through the constructor the same code could power very different games. The combat rules, the fog behavior, the path filters, the turn hooks — same story. Piece by piece, the exploration phase stopped looking like "my game's map system" and started looking like a generic toolkit for hex-based strategy games. That realization became this addon.

I keep updating it as I develop. When I hit friction, need a function that doesn't exist yet, or find a better approach — it goes in here. If you're building something with hexes, I hope this saves you some time. Questions, ideas, or something missing? I'm always happy to chat.

What Pro adds on top of Free

9 strategy-specific modules, a visual map editor, and a full 2-player skirmish demo:

Module	What it does
MapToken	Unit movement with configurable movement points, path following, signals, serialization
TurnManager	Turn cycle with player phases and configurable interval hooks
CombatResolver	Pluggable combat — injectable damage, terrain bonus, flanking, outcome Callables
FlowField	One field serves N units — efficient group movement via trace_path
MapGenerator	Procedural terrain via noise, rivers, scatterable locations
UnitRegistry	Centralized unit tracking by owner, coordinate index with auto-sync, stacking rules
HexMiniMap	Minimap rendering with per-player fog and token markers
TiledImporter	Import Tiled Map Editor JSON maps directly — tilelayers → terrain, objects → tag/metadata
SaveManager	JSON-based save/load slot management with list, delete, validation

Plus:

• HexMapNode (@tool) — paint terrain directly in the Godot editor, auto-serialized, runtime-ready
• 2-player skirmish demo — full source: combat, city capture, fog of war, flow-field group movement, elevation, victory conditions

Free vs Pro — what's the difference?

Free gives you the foundation. Pro gives you the game.

Capability	Free	Pro
Hex grid + offset/cube coordinates	✓	✓
Pathfinding (Dijkstra + A*)	✓	✓
Fog of War (3-state per player)	✓	✓
Hex rendering + batch mode (200×200+)	✓	✓
Camera (follow, drag, zoom, edge-scroll)	✓	✓
Unit movement (MapToken)	—	✓
Turn management (TurnManager)	—	✓
Combat with injectable rules (CombatResolver)	—	✓
Flow field group movement (FlowField)	—	✓
Procedural map generation (MapGenerator)	—	✓
Unit registry + stacking (UnitRegistry)	—	✓
Minimap with fog + tokens (HexMiniMap)	—	✓
Tiled JSON map importer (TiledImporter)	—	✓
Save / load slot system (SaveManager)	—	✓
Visual @tool map editor (HexMapNode)	—	✓
Full 2-player skirmish demo (source included)	—	✓
Modules	7	17
Automated tests	560+	560+ (shared core)
License	MIT	Commercial, royalty-free, unlimited projects
Where to get it	Godot Asset Store · itch.io	itch.io

Pro ships standalone — it includes the full core. You don't need to install the free version separately.

Quick start — Pro features

# Procedural map generation
var grid := MapGenerator.generate_noise_terrain(16, 16, {
    "seed": 42,
    "frequency": 0.08,
    "water_level": -0.25,
    "mountain_level": 0.4,
    "forest_level": 0.1,
})
MapGenerator.generate_rivers(grid, 3)
MapGenerator.scatter_locations(grid, 5, [HexGrid.Terrain.PLAINS])
# Or import a Tiled map
var grid := TiledImporter.from_file("res://maps/my_map.json", my_terrain_fn)
# Token movement with custom movement formula
var token := MapToken.new()
add_child(token)
token.setup(Vector2i(2, 2), grid, func(_level: int) -> float: return 6.0)
token.move_to(Vector2i(5, 5))
# Flow field for group movement (one field, N units)
var field := FlowField.build(grid, Vector2i(10, 10))
var unit_path := FlowField.trace_path(field, Vector2i(2, 2))
# Pluggable combat
var combat := CombatResolver.new()
combat.damage_fn = my_damage_fn
combat.combat_resolved.connect(_on_combat)
combat.resolve(attacker, defender, grid)
# Turns + phases
var turns := TurnManager.new()
turns.setup([0, 1])
turns.player_turn_started.connect(_on_turn_start)
# Save / load
var save_mgr := SaveManager.new()
save_mgr.save(0, {"grid": grid.serialize(), "fog": fog.serialize()})

Every stateful module supports round-trip serialization. Save / load works out of the box, no schema-juggling.

Paint maps in the editor — HexMapNode

HexMapNode is a @tool node: drop it in your scene, pick a terrain from the inspector, and paint hexes directly in the Godot editor. Terrain data is auto-serialized into the node, so the rest of your game reads it as a runtime HexGrid with zero conversion. No external tools, no JSON juggling, no exporters to babysit.

Need to import from somewhere else? TiledImporter reads Tiled Map Editor JSON files directly — tilelayers become terrain, objects become tag/metadata. Use either, mix both, or do procedural and only hand-edit the spawn points.

2-player skirmish — full source included

Hot-seat skirmish with two players, combat, city capture, fog of war, flow-field group movement, elevation-aware LOS, and victory conditions. Built end-to-end on Pro. Read the code, lift what you want, fork it into your own game.

Think of it as a worked example: every Pro module is wired together in a context that makes sense. When you're stuck on "how do I plug UnitRegistry into CombatResolver with stacking?", the demo answers it.

Everything is still injectable

Same design philosophy as Free — every game-specific rule is a Callable you pass in. No subclassing, no magic strings, no hardcoded assumptions:

560+ automated tests

Every module is covered by gdUnit4. Tests run before each release.

HexGrid(98) · HexRenderer(71) · HexMiniMap(52) · FogOfWar(49) · PathFinder(36) · TurnManager(32) · HexCell(29) · UnitRegistry(24) · MapToken(23) · BatchHexLayer(20) · SaveManager(19) · MapGenerator(17) · FlowField(15) · TiledImporter(14) · MapCamera(14) · TerrainPalette(14) · CombatResolver(12) · HexMapNode(11) · Translations(10)

Examples included

Example	Shows
basic_map	Complete API tour — all 17 modules, save/load, 3 phases
strategy_map	2-player skirmish hot-seat — combat, city capture, fog of war, victory
combat_demo	CombatResolver with custom damage and terrain bonus
fog_reveal	FogOfWar + MapToken movement revealing fog
turn_cycle	TurnManager — turn cycle UI
pathfinding	Dijkstra vs A* vs Flow Field — interactive comparison
texture_tiles	Textures, atlases, animated sprites
camera_only	Camera controls + procedural map
map_gen	Interactive procedural generation with sliders

Requirements

• Godot 4.6+
• No external dependencies — pure GDScript
• The free version is not required — Pro ships standalone with the full core

License

Commercial license, royalty-free:

• Unlimited commercial and non-commercial projects
• No revenue cap, no per-game fees
• No attribution required
• Modify and extend freely for your own projects
• Redistribution of the plugin itself is not permitted

Full terms in LICENSE_PRO.md.

A note from the author

I built this because I wanted a hex map plugin that stayed out of the way — no hardcoded assumptions, no magic strings, just clean building blocks you can shape into whatever game you have in mind.

I hope it saves you time and lets you focus on the fun parts. And if you finish your game, please let me know — I'd genuinely love to play it.

islasjavieralf@gmail.com

Acknowledgments

Hex coordinate algorithms informed by Red Blob Games — Hexagonal Grids by Amit Patel.