DEV Community

Zlormack
Zlormack

Posted on

Building a Procedural Top-Down Shooter in Rust with My Custom Game Engine

#rust #gamedev #gameengine #procedural

# Building a Procedural Top-Down Shooter in Rust with My Custom Game Engine

After developing Gemfall Arena, I wanted to answer a new question:

Could my custom Rust game engine support something more complex than a wave-based arena shooter?

That experiment became Zlorma Core: Signal Lost — Prototype v0.1.

Signal Lost is a procedural top-down sci-fi shooter featuring exploration, damaged terminals, collectible resources, defensive structures, corrupted enemies, and a final escape objective.

It is also the second playable game built with my custom engine, ZlormaEngine.

The prototype is available for Windows and #Linux:

https://zlorma-studio.itch.io/zlorma-core-signal-lost-prototype-v01

Moving beyond an arena shooter

Gemfall Arena helped me build and test the first important parts of ZlormaEngine:

  • Software rendering
  • Keyboard and mouse input
  • Player movement
  • Projectiles
  • Enemy spawning
  • Collisions
  • Particle effects
  • Bitmap text
  • Wave progression
  • #Linux and Windows builds

However, its gameplay takes place inside a combat arena.

For my second project, I wanted the engine to support:

  • Exploration
  • Multiple connected rooms
  • Procedural level generation
  • Interactive objectives
  • Collectible resources
  • Player-built defenses
  • Different enemy behaviours
  • A final exit condition

Signal Lost became the project used to implement and test those systems.

The game concept

A digital corruption is spreading through an abandoned station.

The player controls the last maintenance program still online.

Three critical terminals have stopped responding. The station cannot activate its emergency exit until the terminals are restored.

The main gameplay loop is:

  1. Explore the generated station
  2. Locate a damaged terminal
  3. Restore and defend it
  4. Collect data fragments
  5. Build barriers or deploy turrets
  6. Restore all three terminals
  7. Defeat Kernel Error
  8. Reach the emergency exit

The objective was to combine fast top-down combat with light exploration and construction mechanics.

Procedural station generation

The biggest new system is the procedural map generator.

Each run creates a station containing connected rooms and corridors.

The generator must produce a layout that is:

  • Navigable
  • Large enough for combat
  • Small enough to avoid empty exploration
  • Suitable for terminal-defense encounters
  • Compatible with enemy movement
  • Different on each new run

The generated station contains:

  • Floor tiles
  • Solid walls
  • Connected rooms
  • Corridors
  • Three damaged terminals
  • Data fragments
  • Enemy spawn locations
  • Construction areas
  • A boss encounter
  • An emergency exit

This system can later be reused for dungeon crawlers, roguelikes, survival games, and other ZlormaEngine projects.

Terminal restoration

The three terminals provide the main objectives.

The player must explore the map, locate each terminal, and move close enough to begin restoring it.

While the system is being repaired, corrupted programs continue attacking.

This changes the rhythm of the game.

The player is not simply eliminating enemies. They must also decide:

  • Which terminal to restore first
  • Where to stand during a defense
  • Which passage should be blocked
  • When to spend collected fragments
  • Where a turret will be most effective

After all three terminals are restored, the final phase of the run begins.

Data fragments and construction

Signal Lost introduces a simple resource system.

The player collects data fragments while exploring and fighting corrupted programs.

These fragments can be spent on two defensive structures.

Barriers

Barriers can block passages and slow enemy movement.

They are useful for protecting terminals and controlling the direction from which enemies can approach.

Automated turrets

Turrets automatically fire at nearby enemies.

They cost more fragments than barriers but provide additional damage during terminal defense and the final battle.

The construction system is intentionally small in Prototype v0.1.

The goal is to test:

  • Resource costs
  • Object placement
  • Collision updates
  • Automated targeting
  • Structure health
  • Interaction with enemies

More structures can be added after the foundation has been tested.

Corrupted enemy programs

The prototype currently includes several enemy behaviours.

Glitch

Glitch is a small and fast enemy that directly pursues the player.

Its purpose is to apply constant movement pressure.

Corruptor

Corruptor is slower but more dangerous around objectives and defensive structures.

It forces the player to protect more than their own health.

Sentinel

Sentinel attacks from a distance using corrupted projectiles.

This prevents the player from remaining safely behind a single barrier.

Kernel Error

Kernel Error is the final enemy of Prototype v0.1.

It appears during the final stage after the terminal network has been restored.

Defeating Kernel Error unlocks the emergency exit and allows the player to complete the run.

Reorganizing ZlormaEngine

While creating Signal Lost, I also reorganized the engine into a cleaner Rust workspace.

The current structure looks like this:

``text
ZlormaEngine/
├── Cargo.toml
├── crates/
│   └── zlorma_engine/
│       ├── Cargo.toml
│       └── src/
├── games/
│   ├── gemfall_arena/
│   │   ├── Cargo.toml
│   │   └── src/
│   └── signal_lost/
│       ├── Cargo.toml
│       └── src/
├── scripts/
├── docs/
└── dist/
``
Enter fullscreen mode Exit fullscreen mode

The shared zlorma_engine crate contains reusable systems.

Each game remains an independent executable while sharing the same engine foundation.

This organization makes it easier to:

  • Reuse rendering and input code
  • Maintain several games
  • Build the entire workspace
  • Target Linux and Windows
  • Produce release archives
  • Track executable sizes
  • Add future ZlormaStudio projects

Cross-compiling from Linux to Windows

The Linux builds worked correctly, but the first Windows cross-build failed while compiling minifb.

The error was:

``text
At least one of the x11 or wayland features must be enabled
``
Enter fullscreen mode Exit fullscreen mode

The problem came from the dependency features defined in the engine crate.

After correcting the minifb configuration, Cargo correctly detected the required feature:

Enter fullscreen mode Exit fullscreen mode


text
minifb feature "x11"
└── zlorma_engine
├── gemfall_arena
└── signal_lost

Enter fullscreen mode Exit fullscreen mode


plaintext

The complete workspace now compiles successfully for:

Enter fullscreen mode Exit fullscreen mode


text
x86_64 Linux
x86_64 Windows GNU

Enter fullscreen mode Exit fullscreen mode


toml

A single build script creates:

  • Linux executables
  • Windows executables
  • Linux .tar.gz archives
  • Windows .zip archives
  • SHA-256 checksums

Keeping the executables small

One of the original goals of ZlormaEngine was to keep each game executable below 3 MiB.

The release profile uses size-focused settings:

Enter fullscreen mode Exit fullscreen mode


toml
[profile.release]
opt-level = "z"
lto = true
codegen-units = 1
panic = "abort"
strip = "symbols"

Enter fullscreen mode Exit fullscreen mode


plaintext

Current optimized executable sizes are:

| Game | Linux | Windows |
|---|---:|---:|
| Signal Lost Prototype v0.1 | 460 KiB | 296 KiB |
| Gemfall Arena Demo v0.2 | 464 KiB | 312 KiB |
Enter fullscreen mode Exit fullscreen mode

Both games remain comfortably below the original target.

The small size is especially satisfying because the same workspace now supports two different game structures.

What Signal Lost adds to the engine

Signal Lost expands ZlormaEngine with several reusable systems:

  • Procedural map generation
  • Tile-based rooms and corridors
  • Interactive terminals
  • Objective progression
  • Resource collection
  • Construction placement
  • Automated turrets
  • Destructible barriers
  • Multiple enemy behaviours
  • Boss progression
  • Exit activation

Gemfall Arena demonstrates arcade wave combat.

Signal Lost demonstrates exploration, objectives, resource management, and construction inside a generated environment.

Together, the two games provide a much better test of the engine than a single project could.

What I learned

The most important lesson was that a second game quickly reveals which systems are truly reusable.

Code that appears generic inside one project may still contain assumptions about:

  • Map dimensions
  • Enemy spawning
  • Camera behaviour
  • Game states
  • Interface layout
  • Objective progression

Building Signal Lost forced me to separate engine systems from game-specific logic more carefully.

It also showed the value of maintaining a shared workspace early, before creating too many separate projects.

What comes next?

Prototype v0.1 is a technical and playable foundation.

Future versions may include:

  • More station layouts
  • Larger sectors
  • Better enemy navigation
  • Additional corrupted programs
  • New bosses
  • More defensive structures
  • Player upgrades
  • Environmental hazards
  • Difficulty settings
  • Improved visual effects
  • Music and sound effects
  • Saved settings and progression
  • A clearer tutorial

My next priority is to test the core gameplay loop and improve it based on player feedback.

Play Signal Lost

Zlorma Core: Signal Lost — Prototype v0.1 is available for Windows and Linux.

Download it on itch.io:

Feedback about the controls, procedural generation, difficulty, enemy behaviour, and construction mechanics is welcome.

Repair the system. Contain the corruption. Escape.

Developed by ZlormaStudio

Powered by ZlormaEngine

Built with Rust

Top comments (0)