Documentation Docs/en/index.md

FOnline Engine Documentation

This is the human documentation entry point for the reusable FOnline engine. It is written for game developers, tool authors, release operators, and engine contributors working from an Engine checkout without another game’s documentation.

Start here

Getting Started routes a new developer through the repository, supported workflows, and the engine/project ownership split.
First FOnline Headless Project configures, builds, and runs the smallest tested server milestone.
First Playable Client adds a connected desktop client, map loading, and a server-authoritative interaction.
First Content Change follows localized prototype data through baking and runtime lookup.
First Automated Test adds metadata, server-content, and client-visible checks.
Minimal Project and Minimal Multiplayer are the engine-owned runnable sources behind the tutorials.

Build and ship a game

Embedding Project defines the repository boundary between a game and its pinned Engine revision.
Project Configuration covers .fomain, resource packs, sub-configs, overrides, and validation.
Build Workflow covers presets, prerequisites, target selection, and the normal configure/build loop.
Generated Content Workflow gives the dependency order for codegen, scripts, resources, metadata, docs, and site artifacts.
Support Matrix distinguishes verified, smoke-gated, source-capable, experimental, and unsupported combinations.
Packaging and Release owns package declarations, payloads, provenance, signing boundaries, acceptance, publication, and rollback.
Security and Secrets, Release Operations, and Backup and Recovery cover the reusable operational boundaries around a release.
Engine Upgrade Guide defines full-range revision reconciliation, compatibility review, regeneration, and rollback.

Author content

Each guide links to its generated reference when the engine owns a declarative grammar or machine-readable contract. A game owns its concrete catalogs, balance, quests, dialog content, visual policy, and localization policy.

Understand the runtime

Engine Architecture and Source Tree explain where behavior belongs.
Entity and Property Model, Maps, Movement, and Geometry, Authority and Networking, and Persistence — the database facade, commit queue, backend-consistent snapshots, and recovery logs — describe the reusable world model.
Client Runtime, Server Runtime, Frontend and Rendering, and Client Runtime Split and Updater cover the process and presentation layers.
Scripting Runtime, Managed C# Scripting, Script Lifecycle and Concurrency, AngelScript Style and Refactoring, and Remote Calls define the reusable scripting contract.
Frontend and Rendering covers Engine-native rendering and input primitives; high-level GUI libraries are project-owned.

Use tools and validate changes

Mapper Interactive Manual covers daily map editing, history, save discipline, and visible review.
Mapper Tools covers mapper lifecycle, script automation, deterministic screenshots, and headless integration.
Particle Authoring Tools and Animation and Particle Viewers cover focused visual inspection.
Gameplay and Integration Testing, Testing, Debugging, and Profiling route changes to appropriate evidence.
AiControl Protocol and the runnable protocol sample define the project-neutral automation transport and its security boundary.

Reference

Applications lists executable and library entry points.
CMake Project Interface contains exact options, stages, hooks, and project-facing helpers.
BuildTools CLI and Helper CLI contain parser-backed commands, arguments, defaults, choices, and exact help output.
Generated API and Metadata explains the source-annotation, code generation, generated-model, and publication pipeline.
Essentials defines the native foundation layer, its strict include order, allocation vocabulary, and subsystem map.
Public Contract Index routes all generated contract domains and their stability labels.
Script API Method Ownership maps native script exports by runtime side and receiver family.
Native Extension Reference covers roles, hooks, fallbacks, and generated bindings.
Platform Support Matrix records the evidence behind support claims.

Canonical machine-readable models live under Docs/generated/. AI clients should start with llms.txt, use docs-manifest.json for stable document metadata, and load llms-full.txt only when a bounded standalone corpus is appropriate.

Maintain the engine and documentation

Documentation Maintenance defines source ownership, revision reconciliation, regeneration order, and review evidence.
Translation Workflow defines the English source, Russian mirror, glossary, freshness hashes, and code parity.
Site Publication defines the GitHub Pages/Jekyll route, local preview, rendered artifact, and fonline.ru production checks.
Contract Change Management classifies generated-model changes and breaking-change dispositions.
Documentation Snippet Validation and AI Documentation Evaluation define executable examples and retrieval/evidence quality gates.
Native Coding Contracts and Third-Party Maintenance own low-level contributor conventions.

The active production roadmap and verification history remain in Docs/ProductionDocumentationPlan.md, Docs/_meta/DocumentationBacklog.md, and Docs/_meta/DocumentationVerificationReport.md until their planned _meta/ migration has durable redirects.

Ownership boundary

Engine documentation owns reusable runtime behavior, tools, build and platform contracts, formats, generated APIs, and native/script conventions. An embedding project owns concrete game content, product rules, deployment policy, service credentials, and project-specific commands.

Normative Engine procedures must be executable from an Engine checkout and must not depend on Last Frontier, TLA, or another project’s files. External projects may provide version-pinned evidence, but reusable helpers and regressions cited as the source of an Engine guarantee belong in this repository.