Your first Shroudtopia mod

Every mod implements Mod and exports a factory named CreateModInstance. This small example logs lifecycle events and reads a boolean setting. It avoids game-memory writes so you can learn the integration contract first.

Copy#include <windows.h>
#include <string>
#include <vector>
#include <shroudtopia.h>

class ExampleMod final : public Mod {
public:
    ModMetaData GetMetaData() override {
        return {"example_mod", "Lifecycle and config example", "1.0.0",
                "Your name", "0.1.1", true, false};
    }

    void Load(ModContext* context) override {
        context->Log("[example_mod] loaded");
    }

    void Activate(ModContext* context) override {
        active = true;
        context->Log("[example_mod] active");
    }

    void Deactivate(ModContext* context) override {
        active = false;
        context->Log("[example_mod] inactive");
    }

    void Update(ModContext* context) override {
        const bool showNotice = context->config.GetBool(
            "example_mod", "show_notice", true);
        // Read settings here; avoid repeating expensive work every update.
        (void)showNotice;
    }

    void Unload(ModContext* context) override {
        Deactivate(context);
        context->Log("[example_mod] unloaded");
    }
};

extern "C" __declspec(dllexport)
Mod* CreateModInstance() {
    return new ExampleMod();
}

Build a 64-bit DLL. Name it example_mod.dll to match the manifest ID. Put both files in mods/example_mod/. Set active to false until you have checked the code path and target environment.

Learn from preview mods

These examples show how individual DLLs use the framework. They are source walkthroughs, not promises that all mods work on every game build or mode. Read the linked per-mod notes before adapting behavior.

Build, test, and package

Build environment

Use Visual Studio 2022 C++ tools, Windows SDK, x64, and MSVC v143 for the maintained examples. Match runtime and architecture to the loader and game process. Keep build artifacts out of the installed game until your isolated test setup is ready.

Test in layers

1. Compile checks: build with warnings visible and verify exported symbol using your normal PE inspection tooling.
2. Offline tests: test byte matching, version guards, cleanup, and config validation with synthetic inputs where possible.
3. Loader integration: test discovery, manifest defaults, ID/name matching, client/server flags, and disabled-by-default behavior.
4. Isolated gameplay: test only on a backed-up, disposable client or server setup. Confirm activation, deactivation, cleanup, and unsupported-version fallback.
5. Publish honestly: report the exact game build, mode, test scope, and unverified combinations. Link source and retain upstream credit.