Overview

Nilorea RPG

Top-down isometric RPG / MMO-style game written in C using the Nilorea Library and Allegro 5.

Architecture

Component Description
Server (nilorea-server) Authoritative simulation — movement, combat, quests, persistence
Client (nilorea-client) Render-only display + input layer, no game logic
Admin Client (nilorea-client-admin) Client + live in-world map editor (ADMIN_BUILD) — the actual in-game/world editor
Asset Editor (nilorea-assets-editor) Standalone content creation tool (11 modes: sprites, entities, quests, dialogs, particles, objects, tiles, music, interactive objects, asset browser, audit)

All four targets share a common /shared layer (protocol, map structures, definitions, combat logic, asset auditor).

Building

Requires: GCC, Allegro 5, OpenSSL, zlib, PCRE2, libvorbis. Nilorea Library compiled from ../nilorea-library/.

make                    # All four targets
make client             # Player client
make client-admin       # Admin client (ADMIN_BUILD)
make server             # Game server
make assets-editor      # Standalone asset editor (nilorea-assets-editor)
make audit-cli          # Asset auditor CLI (./audit-assets)
make gen-sprites        # Generate placeholder ground-item sprites
make test-<name>        # Run a specific test suite (see Makefile)
make licenses           # Regenerate THIRD_PARTY_LICENSES from the dependency tree
make licenses-check     # CI gate: notice up to date + every source SPDX-stamped
make clean              # Remove build artifacts

The release lives in the root VERSION file and nowhere else: the Makefile compiles it into every binary as GAME_VERSION, stamps it into every package name, and make doc exports it to Doxygen. Each binary answers --version.

Compiler flags: -W -Wall -Wextra -std=gnu17 — zero warnings required.

Platforms: Linux (primary), Windows via MSYS2/MinGW64 or cross-built from Linux with mingw-w64 (make windows).

Packaging (distributables)

Build self-contained, per-target packages — each uses its own icon (assets/icones/<binary>.png) and bundles the shared libraries / DLLs and runtime files it needs. Full walkthrough in docs/packaging.md.

make deb                      # Linux: dist/nilorea-<target>_<ver>_<arch>.deb (all four)
make appimage                 # Linux: dist/<bin>-<ver>-x86_64.AppImage (all four)
make appimage-nilorea-server     #   …or just one target (same for deb-<bin>)
make docker-build             # Release .deb + AppImage set, built in a Debian container
make installer-windows        # Windows (MSYS2/MinGW): dist/<bin>-<ver>-setup.exe (all four)
make windows-deps             # Linux -> Windows cross build: fetch the mingw libraries, once
make windows                  #   cross-build the four .exe with mingw-w64
make windows-installer        #   the four installers, from Linux
make manual                   # Generate HTML docs (each package bundles its own subset)
make manual-check             # Build every manual (fallback + pandoc) and fail on a broken .md link
make licenses                 # Regenerate THIRD_PARTY_LICENSES from the dependency tree
make distclean                # clean + remove dist/

Artefact names carry the release from the root VERSION file — the same value every binary bakes in as GAME_VERSION and reports via --version and the client’s main-menu About dialog. Bump a release with make bump-version (patch + 1; VERSION=x.y.z sets a value; make show-version prints it): no build target changes it. Every package ships LICENSE + THIRD_PARTY_LICENSES (the Windows installer additionally shows the licence on an acceptance page).

make docker-build — reproducible release builds

Builds inside debian:trixie-slim (Debian 13 stable) so the binaries link a known release’s glibc, the .deb Depends: are derived against that release’s packages, and no host-built object leaks into the release. Artefacts are tagged with the Debian codename (nilorea-server_1.0.0-trixie_amd64.deb) to set them apart from the generically versioned local make deb / make appimage testing builds. Requires docker (or podman) and the sibling nilorea-library checkout.

Override Default Effect
BASE_IMAGE debian:trixie-slim Build distro. debian:bookworm-slim (Debian 12) or debian:bullseye-slim (Debian 11, glibc 2.31) target older systems for wider reach, at the cost of an older toolchain. glibc is backward-compatible only, so a trixie build runs on Debian 13+ and never older.
NILOREA_DIR ../nilorea-library Path to the sibling library checkout.
IMAGE nilorea-build:<base> Build image tag.
DOCKER docker Container CLI; may be a multi-word prefix (DOCKER="sudo docker", DOCKER=podman).
TARGETS all four binaries Space-separated subset, e.g. TARGETS="nilorea-server nilorea-client".
SKIP_ASSETS 0 1 omits the asset tree from every package (icons are still copied), turning a multi-GB build into a quick one. Not shippable — pipeline smoke-testing only; the client packages need assets too.
(positional arg) contents of VERSION packaging/docker-build.sh 1.2.3 overrides the upstream version; the codename suffix is still appended.
BASE_IMAGE=debian:bookworm-slim make docker-build              # target Debian 12
DOCKER=podman TARGETS=nilorea-server make docker-build            # one target, podman
SKIP_ASSETS=1 TARGETS=nilorea-client sh packaging/docker-build.sh # quick smoke test

Extra packaging dependencies: - ImageMagick (magick/convert) — regenerates the 256 px PNG + .ico from the source icon (auto-scales/reformats; falls back to another icon if a specific one is missing). - pandoc (recommended) — renders the HTML manual. Without it the build falls back, with loud warnings, to the minimal python3 converter packaging/md2html.py; with neither it fails rather than ship raw markdown. - Linux .deb: dpkg-dev. No root needed. - Linux AppImage: appimagetool (auto-downloaded into build/packaging/), FUSE (libfuse2) or APPIMAGE_EXTRACT_AND_RUN=1, wget. - make docker-build: docker (or podman). - Windows installer: NSIS (pacman -S mingw-w64-x86_64-nsis), built under MSYS2/MinGW so the DLLs resolve via ldd. osslsigncode (pacman -S mingw-w64-x86_64-osslsigncode, MINGW64 environment), NSIS 3.08+ and the NiloreaStudio key for signed packages — see Windows: the signature below. - Windows installer, cross-built on Linux: gcc-mingw-w64-x86-64-posix, binutils-mingw-w64-x86-64, nsis, curl unzip perl for make windows-deps (Allegro’s mingw release, PCRE2 and OpenSSL from source, SHA-256 pinned, into the git-ignored external/mingw/), osslsigncode for signed packages.

Every package bundles assets/, in one of two flavours (packaging/stage-assets.sh): the server and asset editor get the full tree (~3.5 GB); the client and admin client get only the ~7.8 MB boot set — what is read before a server connection exists (locale tables, font, loading/login art, menu track, intro), listed in packaging/boot-assets.txt. Everything else is served: the definition tables in the login sync (~4 MB, hash-checked) and the art and audio on first reference as you play (~181 MB). Every package also ships its audience-scoped HTML manual (the client ones also carry the player guide’s Markdown for the in-game Help → Guide window). See docs/packaging.md for the per-target payload table, the tier breakdown and runtime data-dir behaviour.

Windows: the signature

The four Windows programs, the DLLs beside them, the installers and their uninstallers are signed by NiloreaStudio. The certificate is self-signed: no authority vouches for it, so Windows shows the signature as not trusted, and SmartScreen still warns, until the certificate is installed on the machine. That is optional. The programs run the same without it.

The certificate is NiloreaStudio.cer, in the program’s folder. It is the public half only and cannot sign anything. Check that it is the right one before trusting it:

certutil -hashfile NiloreaStudio.cer SHA256

must print

b9976986aebbfa925b019ee453d9834549b03581fd6ffa28c68f88e6df4a6acd

Then, in a console run as administrator, from the program’s folder:

certutil -addstore Root NiloreaStudio.cer
certutil -addstore TrustedPublisher NiloreaStudio.cer

To undo it:

certutil -delstore Root NiloreaStudio
certutil -delstore TrustedPublisher NiloreaStudio

Installing it makes the machine accept every program signed with that key, so it is the administrator’s decision on a machine that has one. The certificate is limited to signing code and cannot issue other certificates.

A build never creates that key. Made from the sources on a machine that does not hold it, the packages come out unsigned (WIN_SIGN=1 makes that an error), and a machine holding a different key is refused: the Makefile pins the fingerprint above as WIN_SIGN_FINGERPRINT. Copying the key to another build machine, or becoming a new publisher on purpose, is described in docs/packaging.md § Version resource, strip and signature.

Project Structure

client/         Game client (render, input, UI, admin editor)
server/         Game server (simulation, AI, persistence, networking)
editor/         Standalone content editor (11 modes incl. asset auditor)
shared/         Code compiled into all targets (protocol, maps, defs, combat, asset auditor)
assets/         Game content (JSON definitions, sprites, sounds, maps)
                + .auditignore for orphan exemptions
docs/           Architecture docs, protocol changelog, format specs, hot-reload
tests/          Test suites (~30 test targets)
tools/          Utility tools (sprite generator, asset auditor CLI, JSON migrator)

Running

  1. Start the server: ./nilorea-server
  2. Start the client: ./nilorea-client (or ./nilorea-client-admin for map editing)
  3. Connect via the main menu (default: localhost:4242)

Key Features

Documentation

Start here (reader-facing guides, also in French):

The guides are overlay + link — they point into the canonical references below for exact numbers/formats. Reference docs:

License

Freeware. Copyright (c) 2026 Castagnier Mickael (gullradriel). All rights reserved. Nilorea RPG is free to install and use, in the binary form published by the author, for any lawful purpose. It is not for sale, and it may not be modified or redistributed, in source or binary form, except under a separate written agreement. See LICENSE for the full terms. Every first-party source file carries the copyright line and the private label SPDX-License-Identifier: LicenseRef-Proprietary (python3 tools/stamp_license.py --check verifies none was missed).

Third-party components keep their own licenses; THIRD_PARTY_LICENSES has the complete list and the license texts, and is regenerated by make licenses. Four obligations are worth knowing before changing dependencies: