Architects Of Intelligence
A turn-based digital board game about building AI-powered cities, with a content pipeline designers can extend without touching code.
features.idx (8 features)
- overview
- what_i_did
- features/
- 01Data-Driven Dynamic Resource Architecture
- 02Decoupled Game State & Turn Management Architecture
- 03Interactive 2D Grid Placement System
- 04Dynamic Construction & Resource Validation Dock
- 05Formulaic Resource Harvesting & Transaction Engine
- 06Multi-Player State & Ledger System
- 07Interactive Dice Rolling & Resolution Utility
- 08Knowledge Card & Peer Trading Systems
Project overview
Architects Of Intelligence is a turn-based digital board game and resource management strategy game developed in Godot 4.6. Players manage and expand technological municipal empires on an interactive 2D grid, competing as city mayors to develop advanced AI infrastructures while balancing critical urban utilities.
The core gameplay loop blends strategic city-building, economic simulation, and risk management across phased game turns: players construct foundational city structures, power plants, water treatment facilities, and evolving tiers of AI systems (Generative AI, Theory of Mind AI), while managing real-time economies of Money, Electricity (MW), Water (ML), and Citizen populations.
Turns progress through structured setup and harvest phases where dynamic mathematical resource formulas and physical dice rolls calculate resource yields, maintenance costs, and population shifts, supported by interactive knowledge card decks and complex player trading systems.
What I did
As the solo developer and systems architect, I engineered the entire digital game client from scratch in Godot 4.6 using GDScript.
I architected an extensible, zero-hardcoding data pipeline (GameDefinition) that scans and loads modular custom .tres resources at runtime using DirAccess. This decouples game logic from content, allowing game designers to introduce new buildings, cards, economic resources, and balance configurations without recompiling or modifying the codebase.
I designed the state authority architecture (centralized GameManager, GameStateManager, PlayerStateManager, and TurnManager), engineered the interactive TileMapLayer grid placement system with footprint previews and spatial hash occupancy tracking, implemented the formulaic harvest and transaction engine with dice rolls, and created modular UI docks for construction, trade negotiation, and card management.
Solo project · Solo Gameplay Programmer & System Architect
Features I implemented
Data-Driven Dynamic Resource Architecture
To eliminate hardcoded gameplay data and allow game designers to easily tune balance or add new assets, I built an extensible runtime content pipeline inside GameDefinition. At boot, the engine automatically scans designated subfolders inside res://definitions/ and dynamically loads custom Godot .tres resources.
The loader uses Godot's DirAccess API to inspect directory contents, filters for valid resource files while stripping export remap suffixes (.remap), and hydrates type-safe arrays for game resources, structure definitions, player color palettes, knowledge cards, card types, and trade configurations.

- GameResource: Defines economic currencies (Money, Electricity in MW, Water in ML, Citizens) and UI display properties.
- StructureResource: Configures build costs, on-build earnings, multi-turn harvest formulas, footprint dimensions, and tier progression.
- PlayerColorResource: Defines distinctive player thematic color palettes and shader modulations.
- KnowledgeCardResource & CardTypeResource: Defines deck cards, action effects, and trade categories.
func _load_resources_from_folder(folder_name: String, resource_variable: Array) -> void:
# Open the folder
var path: String = BASE_RESOURCES_FOLDER_PATH + folder_name + '/'
var dir = DirAccess.open(path)
if dir != null:
# Get a list of every file inside that folder
var files = dir.get_files()
# Cycle through them one by one
for file_name in files:
# (See the Pro-Tip below about this .remap line!)
var clean_name = file_name.trim_suffix('.remap')
# Only load .tres files (ignore things like imported images or hidden files)
if clean_name.ends_with('.tres'):
# Build the full path (e.g., 'res://game_resources/gold.tres')
var full_path = path + clean_name
# Load it and cast it
var loaded_res = load(full_path)
# If it successfully loaded as a GameResource, add it to our array!
if loaded_res != null:
resource_variable.append(loaded_res)
print('Loaded ', resource_variable.size(), ' resources dynamically!')
else:
print('Error: Could not open folder at ', path) Decoupled Game State & Turn Management Architecture
I architected a decoupled state authority model separating persistent game data from phase-driven execution logic. Centralized under an autoloaded GameManager, state ownership is divided between GameStateManager (tracking world state, player profiles, and cell occupancies) and TurnManager (controlling phase progression and action queues).
The turn loop executes as a state machine transitioning between IDLE, HARVEST_RESOURCES, and PLAYER_IS_CHOOSING_ACTION. During harvest phases, TurnManager builds an automated queue of HarvestAction objects from player-built structures, requests physical dice rolls, and evaluates complex yields asynchronously before transferring control to the local player or AI.
- Centralized Autoload (GameManager): Mediates cross-system signals, keeping UI widgets decoupled from underlying game logic.
- GameStateManager: Tracks all player state instances and maintains the global spatial board registry.
- TurnManager: Manages turn phases, harvest formula aggregation, and player action gating.
- TurnPhase State Machine: Ensures strict sequential flow from resource calculation to interactive decision-making.
func _change_phase(new_phase: TurnPhase) -> void:
current_turn_phase = new_phase
match current_turn_phase:
TurnPhase.HARVEST_RESOURCES:
_harvest_resources_phase()
return
TurnPhase.PLAYER_IS_CHOOSING_ACTION:
_player_is_choosing_action_phase()
func _do_harvest_resource():
if harvest_queue.is_empty():
_change_phase(TurnPhase.PLAYER_IS_CHOOSING_ACTION)
return
var harvest_action: HarvestAction = harvest_queue.front()
var dice_amount: int = harvest_action.formula.number_of_dice_to_roll
GameManager.roll_dice(dice_amount) Interactive 2D Grid Placement System
I built the GridPlacementSystem to handle intuitive tile-based construction on Godot's TileMapLayer. The engine translates screen coordinates to grid coordinates via local_to_map, calculating the full multi-cell footprint of the selected structure in real time.
To provide clear visual feedback, I created dynamic footprint previews with a ColorRect bounding box (green for valid placement, red for blocked cells) and semi-transparent sprite modulation. Cell occupancy is checked against a spatial dictionary (Dictionary[Vector2i, Structure]) to guarantee O(1) collision lookups. Grid lines are dynamically drawn in canvas coordinates using _draw() and updated when the viewport resizes.

func _place_building() -> void:
if not _is_footprint_clear(current_grid_pos):
return
var structure_node: Structure = STRUCTURE_RESOURCE.instantiate()
structure_node.global_position = ground_tile_map_layer.map_to_local(current_grid_pos) + visual_offset
built_structures.add_child(structure_node)
structure_node.tile_size = ground_tile_map_layer.tile_set.tile_size
structure_node.structure_resource = current_building_structure
structure_node.cell_position = current_grid_pos
structure_node.player_owner_index = player_owner_index
structure_node.change_color(building_color)
for offset in footprint:
var claim_pos = current_grid_pos + offset
GameManager.add_occupied_cell_to_board(claim_pos, structure_node)
_reset()
emit_signal("structure_built", current_grid_pos) Dynamic Construction & Resource Validation Dock
I developed BuildUtility, a responsive construction dock that populates buildable items directly from active GameDefinition resources. Icons are automatically shaded using the active player's thematic color palette.
The dock continuously monitors the player's economic balances (Money, Power, Water, Citizens). When resources drop below a building's cost, the item is dynamically disabled in the list, preventing invalid placement attempts. The system also tracks construction limits per player and handles automatic tier upgrades.
func _compute_buildable_structures_based_on_available_resources():
if not cannot_build_on_resources_below_required:
return
var current_player_resources: Dictionary[String, float] = GameManager.get_current_player_resources()
for item_index in range(item_list.item_count):
var structure: StructureResource = item_list.get_item_metadata(item_index)
var building_costs: Array[Transaction] = structure.building_cost
var is_disabled: bool = false
for cost in building_costs:
var resource_name: String = cost.resource_type.name
if current_player_resources[resource_name] < cost.amount:
is_disabled = true
break # The player can't afford this, STOP checking the other costs!
# print("Build List Update | structure: [", structure.name, "], can be built: [", is_disabled,"]")
item_list.set_item_disabled(item_index, is_disabled) Formulaic Resource Harvesting & Transaction Engine
I implemented an extensible economic simulation engine powered by GameResourceFormula and HarvestAction. Rather than fixed output values, production in Architects Of Intelligence is dynamic, factoring in physical dice roll values, scaling multipliers, and structure counts.
The engine supports both single-structure calculations and aggregate multi-structure evaluations (where the total yield scales with the number of operational facilities in the city). Production formulas handle positive income, maintenance consumption, and population growth shifts across all four core resource types.
func dice_rolled(rolls: Array[int]):
if TurnPhase.HARVEST_RESOURCES:
var harvest_action: HarvestAction = harvest_queue.pop_front()
var harvest_formula: GameResourceFormula = harvest_action.formula
var dice_sum: int = rolls.reduce(func(accum, number): return accum + number, 0)
var new_value: float = harvest_formula.formula_sign * dice_sum
# if harvest is not due to single structure but by the "sum" of the structures
# we multiply here the resource
if harvest_formula.is_single_formula_for_all_structures_of_same_type:
var resource_type_key: String = harvest_formula.single_formula_for_all_structures_of_same_type_sum_multiplier_resource_type.name
new_value *= GameManager.get_current_player_resource_from_key(resource_type_key)
new_value *= harvest_formula.multiplier_value
var producting_structure_built_data: BuiltData = harvest_action.producting_structure_built_data
GameManager.update_current_player_resource(harvest_formula.resource_type, new_value, producting_structure_built_data)
_do_harvest_resource()
return Multi-Player State & Ledger System
To support turn-based matches across multiple mayors, I designed independent PlayerStateManager instances that encapsulate individual player data.
Each state manager maintains its own dictionary of resources, a catalog of owned structures indexed by cell coordinates, a hand of knowledge cards, and setup queues. The system links seamlessly with PlayerColorResource definitions for UI icon modulation and board piece coloring, while supporting CPU player pacing timers.
- Independent Resource Ledgers: Floating-point tracking of dynamic resources
- Owned Structure Registry: Dictionary[String, Array[BuiltData]] mapping building categories to cell positions.
- Turn State Isolation: Ensures actions, costs, and earnings are strictly applied to the active player.
Interactive Dice Rolling & Resolution Utility
I built an event-driven dice rolling subsystem (DiceRollUtility) that bridges physical board-game randomness with digital simulation. The system dynamically queries the number of dice required by the active turn formula.
For local human players, the utility surfaces an interactive rolling interface with randomized animations and result prompts. For non-local or CPU turns, it computes automated hidden rolls without interrupting pacing. Once rolled, the array of integer outcomes is broadcast via signals to TurnManager for immediate formula evaluation.

Knowledge Card & Peer Trading Systems
I programmed KnowledgeCardUtility, an interactive 5-slot card desk allowing players to draw, inspect, and play knowledge cards during their turn. Cards can introduce municipal bonuses, research perks, or strategic challenges.
Alongside cards, I implemented MakeTradeOfferView and TradeComponent to power bilateral peer trading. The trade interface lets players negotiate deals by offering and requesting combinations of currencies, knowledge cards, and special items, validating ownership before executing atomic transactions between player state ledgers.

Like what you see?
Get in touch to talk about how it was built.