Termule.Engine 0.5.2

Termule.Engine

A micro game engine for developing real-time terminal games. See the full toolkit here.

Access

This library is available on NuGet as Termule.Engine. To add it to your project use:

dotnet package add Termule.Engine

Structure

Termule splits its runtime behavior into two types: Core.System and Core.Component.

Systems

• Provide a home for global behavior and data
• Can only be installed, uninstalled, or swapped before the game runs
• Are limited to a single instance, easily accessed by other systems or components
• Allow complex behavior to be moved out of the component tree

Components

• Provide a home for modular behavior and data
• Can be created, destroyed, or moved while a game is running
• Can be grouped by a GameObject to enable collaboration
• Allow behavior to live close to data when it makes sense

This structure provides the convenience of typical OOP while maintaining flexibility. By moving a large chunk of behavior out of the world and into systems, Termule makes games more organized (and in many cases more performant) at scale.

An example game structure:

Game
 ├── Systems
 │    ├── RenderSystem
 │    ├── Terminal
 │    └── TerminalController
 └── World
      ├── Player
      │    ├── Transform
      │    ├── ContentRenderer
      │    ├── PlayerController
      │    └── Camera
      └── Enemy
           ├── Transform
           ├── ContentRenderer
           └── EnemyController

Features

Rendering

The most notable characteristic of the Termule engine is its ability to render the game world so that it can be displayed by terminals. This is achieved through a software renderer that works not on pixels, but terminal cells containing a glyph and two RGB colors (one for the background and one for the glyph itself).

Types.Cell
 ├── Color
 ├── Glyph
 └── GlyphColor

Every Renderer implements a Render() method which is invoked by the RenderSystem when it is time to render the world. This is less performant than the typical render pipeline approach, but makes implementing custom renderers much easier. To this end, Termule provides a collection of drawing methods that perform common operations like drawing sprites, lines, and circles.

Display

To complement its rendering system, the Termule engine provides performant DisplaySystem implementations for terminals. These systems make use of virtual terminal escape sequences to display complex, colorful visuals across a wide range of terminal environments.

At the end of the day, terminal emulators are essentially just interpreters for text that produce visual output on the screen. For this reason, it is important to minimize the number of escape sequences that the terminal has to interpret. This includes optimizations like only drawing cells that have changed since the last tick and drawing chunks of the same color in a single sequence. These optimizations allow Termule programs to run at the frame rates expected of modern games, even in the terminal.

Input

The engine's input system works fully through the terminal without any external input library. This is achieved by enabling and parsing platform-specific escape sequences generated by keyboard and mouse input. This requires bypassing the C# console API in order to get direct, buffer-free access to input.

As it stands the main system for input, Systems.Input.TerminalController can parse:

• SGR
• Plain CSI
• Kitty CSI
• SS3
• ASCII

And emits messages on:

• ButtonDown
• ButtonUp
• CharTyped
• MouseMoved

Resources

As it stands, the runtime resource loading system is quite bare-bones. Types marked as IResource can be loaded and deserialized from JSON at runtime through a Systems.Resources.ResourceLoader. The engine's internal serializer supports 2D arrays, so types like Image are fully loadable.

Resources are sourced as streams by an IResourceProvider. The default resource provider exposes resources that are embedded in the entry assembly. This facilitates publishing to a single, self contained executable.

Documentation

Documentation for the engine's API is available at https://v30p.github.io/termule. This documentation is also viewable by hovering over a Termule type or member in most IDEs.