Start here: developing for LonelyIce

How LonelyIce is put together

LonelyIce is one program, LonelyIce.exe: a launcher, an AzerothCore-based server and a package manager. The server core is a fork of AzerothCore with a plugin loader. A plugin is a folder with a plugin.json and, usually, a shared library of ordinary AzerothCore scripts, built with the core's AddPlugin() CMake function. The loader is part of the core, so the same plugin also runs in a plain worldserver of the fork, without the launcher.

Everything you publish follows three rules:

It works in a plain worldserver of the fork, not only under LonelyIce.
It never sees the database backend: SQL is written in the AzerothCore (MySQL) dialect and all access goes through the core's database interfaces.
It never hard-codes the id of a client DBC row it adds: it names the row in a patch recipe and the installer gives out the id.

What you can build

You want to	You build	Start with
Add gameplay: hooks, commands, NPCs, spells, tables, settings, a client addon	a plugin	Your first plugin
Ship an existing AzerothCore module without forking it	a wrapped module	Wrapping an AzerothCore module
Run the server's databases somewhere else than SQLite files	a storage plugin	Storage plugins
Add spells or other DBC rows, icons and files for the game client	a patch recipe inside a plugin (a plugin may carry only data and client files)	Client patches
Offer packages from your own server or folder	a catalog	Hosting your own catalog
Change the core, the launcher or the package manager	a core or launcher change	Building the core, Contributing

What you need

A LonelyIce installation that has been set up once, and the 3.3.5a game client (build 12340) it uses, to test in.
For server code, the build tools of Building LonelyIce. On Windows: Visual Studio 2022, CMake 3.22 or newer, Git, Boost 1.87 and OpenSSL 3. The Linux and macOS builds have not been tested yet.
A build of the same LonelyIce release you run. A plugin library only loads into the core build it was compiled against (core.abi, currently lonelyice-ac-2).
A text editor for JSON and SQL. A plugin without server code (patch recipes, client addons, SQL only) needs no compiler.

Reading order

1. Understand the pieces.

Install layout: where the program, plugins, configs and data live.
How the launcher runs the server: launcher, server process and wizard.
The core fork: what the fork changes in AzerothCore.

2. Build a plugin.

Your first plugin: manifest, script, entry point, build, pack, install.
Plugin settings: a config file and a group in the launcher's Settings.
Shipping SQL: tables and rows on every backend.
Client patches: new DBC rows with named ids.
Plugin cookbook: hooks, commands, databases, gossip, translations, playerbots.

3. Look things up.

Plugin format: every manifest field, settings, patches, packages.
Plugin API: AddPlugin, entry macros, load order, sPluginMgr.
Command line, lonelyice.ini, Environment variables: running and configuring LonelyIce by hand.
Server game data: what the server reads from the client.
The package manager: install, update and dependency resolution.

4. When something goes wrong.

Debugging plugins: logs, loader messages, running the server by hand, a debugger.

5. Ship it.

Versions and dependencies: version numbers, depends and conflicts.
Publishing a package: from a built plugin to the catalog.
Package review: what the catalog checks before a package goes live.
Hosting your own catalog: serving packages yourself.

Other paths.

Wrapping an AzerothCore module and Storage plugins.
Building the core and Contributing for changes to the fork or to LonelyIce itself.

Where the code lives

Everything is under github.com/LonelyIceProject:

Repository	What it holds
`lonelyice`	The program: launcher, server process, package manager, the release build. Its `plugins/` are the shipped plugins, as submodules.
`azerothcore-wotlk`	The core fork with the plugin loader (`src/server/shared/Plugins`, `doc/Plugins.md`).
`mod-playerbots`	Playerbots, built as the `playerbots` plugin.
`mod-lonelyice-*`	LonelyIce's own plugins (`qol`, `waystones`, `citizens`, `tactics`, `mysql`): the best examples to copy from.
`<module>-plugin`	Wrappers that build third-party AzerothCore modules as plugins.

The homepage in a mod-lonelyice-* plugin's plugin.json points at its repository; wrappers and playerbots point at the upstream module instead.

Where to ask

Ask on the forum (Forum in the site header): questions, ideas and plugins in progress are all welcome there. Bug reports go to the forum or to the issues of the repository concerned; Support lists what a good report contains.