Build and ship SCP: ReEnter mods.

📋 Table of Contents

🛠️ 1. Prerequisites

Before creating and publishing mods, ensure you have the following components prepared:

1. Up-to-date SCP: ReEnter Dedicated Server installation;
2. Official Modding SDK containing a compatible Unreal Engine build and the SCPModAPI plugin;
3. SteamCMD and a Steam account authorized to publish Workshop items for AppID 4088120;
4. Windows 64-bit development environment;
5. A custom square preview image for your mod (e.g. preview.png, 512x512 recommended).

Document Notation & Variables

Throughout this documentation, the following placeholders are used:

📁 2. Creating the Mod Project

Screenshot 1 — Plugin Configuration Edit → Plugins

The Edit → Plugins dialog showing the SCPModAPI plugin enabled with its module active.

🗂️ 3. Mandatory Content Hierarchy

In the Unreal Content Browser, you must create a dedicated root folder under Content/Mods/ named exactly after your <MOD_ID>:

Content/Mods/<MOD_ID>/

Recommended organizational folder layout for larger mods:

Content/Mods/<MOD_ID>/
├── BP_<MOD_ID>         (Entry Blueprint Actor)
├── Actors/             (Custom Replicated Blueprints)
├── Audio/              (Sound Waves, Sound Cues)
├── FX/                 (Niagara Systems)
├── Materials/          (Materials, Material Instances)
├── Meshes/             (Static Meshes)
└── Textures/           (Texture 2D Assets)

Screenshot 2 — Content Browser Layout Content/Mods/<MOD_ID>

Content Browser layout displaying the root Content/Mods/<MOD_ID> directory with the entry Blueprint and structured asset subfolders.

🧩 4. Entry Blueprint Actor

The dedicated server initializes and executes your mod through an entry actor subclassed from the Mod API:

1. Inside Content/Mods/<MOD_ID>, right-click and select Blueprint Class.
2. In the search box under All Classes, select SCP Mod Base Actor (SCPModBaseActor) as the parent class.
3. Name the Blueprint: BP_<MOD_ID>.
4. Open the Blueprint and compile it to verify there are no errors.

Screenshot 3 — Blueprint Parent Class Class Settings

The Class Settings panel for BP_<MOD_ID> with Parent Class set to SCP Mod Base Actor.

Available Lifecycle Events

Your entry actor provides built-in lifecycle hooks that execute automatically during match execution on the server:

🔗 5. Asset Referencing Paths

The SCPModAPI nodes accept a Mod ID string and a Relative Path string. Do NOT prepend /Game/Mods/... to the relative path argument.

🧱 6. Adding Supported Assets & Replication

6.1 Static Meshes, Textures & Materials

1. Import your 3D mesh (FBX/OBJ) into Meshes/, and textures into Textures/.
2. Create your Material or Material Instance inside Materials/ and assign it to the mesh.
3. In BP_<MOD_ID> under On Round Start, add a Spawn Replicated Mod Prop node.
4. Connect Get Mod Id to the Mod ID pin.
5. In Relative Mesh Path, enter (for example) Meshes/SM_Crate.SM_Crate.
6. Set the Spawn Transform in Unreal units (100 units = 1 meter).

Materials and textures applied to the mesh are loaded automatically as dependencies. To dynamically override a material at runtime, store the returned SCP Mod Replicated Prop reference and call Set Replicated Material From Mod Path. This update is automatically replicated to all connected and late-joining clients.

6.2 3D Replicated Audio

1. Import your WAV audio file into Audio/.
2. Use a Sound Wave directly or wrap it in a Sound Cue (for spatial randomization or pitch modulation).
3. For ambient looping audio, enable the Looping property within the sound asset.
4. In your Blueprint graph, call Spawn Replicated Mod Sound.
5. Configure the relative path, transform, and parameters:
   • Auto Play — Starts playback immediately upon spawn;
   • Spatialized — Enables 3D positional audio;
   • Inner Radius — Radius within which audio plays at maximum volume;
   • Falloff Distance — Maximum hearing distance where sound fades to silence;
   • Volume Multiplier & Pitch Multiplier.

The returned SCP Mod Replicated Effect object can be controlled at runtime with Set Replicated Mod Sound Playing or Restart Replicated Mod Sound. Playback timestamp and state are synchronized over the network so late-joining players hear long-running ambient sounds at the exact current position without restarting.

6.3 Niagara Particle Systems

1. Inside FX/, create or copy a complete Niagara System (not just an isolated emitter).
2. Move all referenced materials, textures, and sprites inside your mod root directory.
3. Ensure you configure explicit Fixed Bounds on the Niagara System to prevent premature camera culling.
4. In your graph, call Spawn Replicated Mod Niagara (with Auto Activate enabled).

Control the effect dynamically using Set Replicated Mod Niagara Active. The dedicated server replicates lifecycle state and timestamps, while client GPUs render and simulate particles locally.

6.4 Custom Blueprint Actors (Advanced)

For complex interactive gameplay elements (such as scripted doors, interactive terminals, or hazards), create a custom Blueprint Actor inside Actors/:

• In Actor Defaults, enable Replicates (and Replicate Movement if the actor moves).
• Spawn it on the server using Spawn Replicated Mod Actor By Path.
• Ensure all custom gameplay variables are explicitly configured with Replicated or ReplicatedUsing.

6.5 Generic Asset Loaders

For auxiliary logic, the API provides helper loaders: Load Mod Static Mesh, Load Mod Material, Load Mod Sound, Load Mod Niagara System, Load Mod Class, and Load Mod Asset Generic.

6.6 Interacting with Pawns & Gameplay Variables (Reflection & Wildcards)

Mods frequently need to read or mutate character properties (such as player Health, Stamina, bIsExhausted, movement speeds, or SCP attributes) without having a static compile-time class dependency on the game's C++ codebase.

Inside the SCP|Modding|Reflection category, SCPModAPI provides a native reflection engine exposed directly to Blueprints.

A. Blueprint Wildcard Nodes (Universal Auto-Adapting Pins)

Using Unreal Engine's CustomThunk and CustomStructureParam pipeline, these nodes dynamically adapt their pin types and colors to any connected variable:

B. Explicit Type-Safe Helper Nodes

For convenience and strict type guarantees, dedicated typed nodes are also available with automatic numeric conversion:

C. Dynamic Function Invocation & Property Queries

• Has Object Property — Pure node returning True if the property exists on the target class.
• Has Object Function — Pure node returning True if a callable function exists on the target class.
• Call Object Function By Name — Dynamically executes any UFunction on the target object with optional space-separated parameters (e.g. "ApplyDamage 50.0").

🍳 7. Packaging & Cooking Configuration

Unreal Engine does not automatically cook assets that are not directly referenced by a project's default startup map. To ensure your mod assets are properly cooked:

1. Open Edit → Project Settings → Packaging.
2. In Additional Asset Directories to Cook (under Packaging advanced settings), add: /Game/Mods/<MOD_ID>.
3. Ensure Use Io Store is unchecked (disabled). Standalone mod PAKs require traditional cooked loose files for compatibility with UnrealPak.exe.
4. Save all dirty assets (File → Save All).
5. Right-click your mod root folder in the Content Browser and select Fix Up Redirectors in Folder.
6. Compile your Blueprint actor and ensure all errors and critical warnings are resolved.

Screenshot 5-1 — Packaging Settings Project Settings

Configuring /Game/Mods/<MOD_ID> in Additional Asset Directories to Cook.

Screenshot 5-2 — Disable Io Store Use Io Store: Unchecked

Ensure Use Io Store is unchecked / disabled so that cooked assets generate standard files mountable by UnrealPak.exe.

Then navigate to Platforms → Windows → Cook Content and wait for the completion notification. Cooked binaries will be generated at:

<MOD_PROJECT>\Saved\Cooked\Windows\<PROJECT_NAME>\Content\Mods\<MOD_ID>\

The folder will contain cooked .uasset, .uexp, and optionally .ubulk files. In addition, the root cooked Content directory will contain vital shader bytecode archives:

ShaderArchive-<PROJECT_NAME>-PCD3D_SM5-PCD3D_SM5.ushaderbytecode
ShaderArchive-<PROJECT_NAME>-PCD3D_SM6-PCD3D_SM6.ushaderbytecode

📦 8. Building the PAK File

Create a staging directory: <MOD_PROJECT>\WorkshopContent. Do NOT place raw un-cooked source files, C++ source, plugins, passwords, or VDF scripts in this folder — only the final .pak file intended for players.

Use the following PowerShell script to automatically build the PAK with the correct mount points and shader libraries. Adjust the top 4 variables for your environment:

# ==========================================
# SCP: ReEnter Mod Packaging Script
# ==========================================
$ModProject     = 'W:\UEProjects\dummy'
$ModEngine      = 'W:\UE5.7.4\UE_5.7'
$ProjectName    = 'dummy'
$ModId          = 'MyCustomMod'

$CookedContent   = Join-Path $ModProject "Saved\Cooked\Windows\$ProjectName\Content"
$CookedMod       = Join-Path $CookedContent "Mods\$ModId"
$WorkshopContent = Join-Path $ModProject 'WorkshopContent'
$PakFile         = Join-Path $WorkshopContent "$ModId.pak"
$ResponseFile    = Join-Path $ModProject 'pak_list.txt'
$PakMount        = "../../../$ProjectName/Content/Mods/$ModId"

New-Item -ItemType Directory -Force -Path $WorkshopContent | Out-Null

# Recursively collect cooked assets to preserve subfolder hierarchy and avoid filename collisions
$CookedFiles = Get-ChildItem -Path $CookedMod -Recurse -File
$PakEntries = [System.Collections.Generic.List[string]]::new()

foreach ($File in $CookedFiles) {
    $RelativePath = $File.FullName.Substring($CookedMod.Length).TrimStart('\', '/').Replace('\', '/')
    $PakEntries.Add(('"{0}" "{1}/{2}"' -f $File.FullName, $PakMount, $RelativePath))
}

# Add required shader bytecode libraries
$ShaderSM5 = Join-Path $CookedContent "ShaderArchive-$ProjectName-PCD3D_SM5-PCD3D_SM5.ushaderbytecode"
if (Test-Path $ShaderSM5) {
    $PakEntries.Add(('"{0}" "{1}/ShaderArchive-{2}-PCD3D_SM5-PCD3D_SM5.ushaderbytecode"' -f $ShaderSM5, $PakMount, $ProjectName))
}
$ShaderSM6 = Join-Path $CookedContent "ShaderArchive-$ProjectName-PCD3D_SM6-PCD3D_SM6.ushaderbytecode"
if (Test-Path $ShaderSM6) {
    $PakEntries.Add(('"{0}" "{1}/ShaderArchive-{2}-PCD3D_SM6-PCD3D_SM6.ushaderbytecode"' -f $ShaderSM6, $PakMount, $ProjectName))
}

$PakEntries | Set-Content -LiteralPath $ResponseFile -Encoding ascii

# Remove existing PAK archive to avoid UnrealPak overwrite errors
if (Test-Path $PakFile) {
    Remove-Item $PakFile -Force
}

& "$ModEngine\Engine\Binaries\Win64\UnrealPak.exe" $PakFile "-create=$ResponseFile"
& "$ModEngine\Engine\Binaries\Win64\UnrealPak.exe" $PakFile -list

Mount Point Verification

The -list command output must confirm a mount point matching:

../../../<PROJECT_NAME>/Content/Mods/<MOD_ID>/

🧪 9. Local Server Testing (mod.json)

Before publishing to Steam Workshop, test your mod locally on your dedicated server installation. In your server directory, create:

<SERVER_ROOT>\SCPReEnter\Mods\<MOD_ID>\
├── <MOD_ID>.pak
└── mod.json

Sample mod.json Manifest

{
  "ModId": "MyCustomMod",
  "WorkshopId": 0,
  "Name": "My Server Mod",
  "Version": "1.0.0",
  "Author": "Your Name",
  "Description": "Replicated content mod for my server.",
  "EntryActorClass": "/Game/Mods/MyCustomMod/BP_MyCustomMod.BP_MyCustomMod_C",
  "Priority": 500,
  "bIsEnabled": true,
  "RequiredEngineVersion": "5.7"
}

Screenshot 6 — Server Mod Directory SCPReEnter/Mods/<MOD_ID>

Ecosystem view of the server directory containing exactly the PAK file and mod.json manifest.

Start your dedicated server and check the console output. Look for the following initialization log messages:

[ModSubsystem] Resolving class for mod '<MOD_ID>'
[ModSubsystem] Resolved ModActorClass
[ModActor] Mod '<MOD_ID>' OnModLoaded executed.
[ModSubsystem] Spawned and initialized mod actor

🚀 10. Publishing to Steam Workshop

10.1 VDF Configuration File

Alongside your project (outside of WorkshopContent), create upload_item.vdf:

"workshopitem"
{
    "appid"              "4088120"
    "publishedfileid"    "0"
    "contentfolder"      "W:/UEProjects/MyModProject/WorkshopContent"
    "previewfile"        "W:/UEProjects/MyModProject/preview.png"
    "visibility"         "2"
    "title"              "My Server Mod"
    "description"        "Content mod used by my SCP: ReEnter server."
    "changenote"         "Initial release"
}

visibility options: 0 (Public), 1 (Friends Only), 2 (Private — Recommended for initial testing), 3 (Unlisted).

10.2 SteamCMD Upload Execution

Execute SteamCMD from PowerShell:

& 'E:\SteamLibrary\steamapps\common\SteamCMD\steamcmd.exe' +login YOUR_STEAM_LOGIN +workshop_build_item 'W:\UEProjects\MyModProject\upload_item.vdf' +quit

Enter your Steam password and Steam Guard code when prompted. Upon successful upload, SteamCMD will print your new Published File ID. Update publishedfileid in your VDF file with this number so subsequent executions update the existing Workshop item rather than creating duplicates.

Screenshot 7 — Steam Workshop Item ID Steam Community

Steam Workshop page URL showing the numeric ?id=<WORKSHOP_ID> parameter.

☁️ 11. Enabling Automatic Client Downloads

Once your mod is published to Steam Workshop:

1. Set the real <WORKSHOP_ID> in your server's SCPReEnter/Mods/<MOD_ID>/mod.json under "WorkshopId".
2. Verify that the PAK on your server is the exact same binary artifact uploaded to Steam Workshop.
3. Check your server instance configuration at: <SERVER_ROOT>\SCPReEnter\ServerConfig\<PORT>\ServerConfig.ini.

[/Script/SCPReEnter.ServerSettings]
bEnableWorkshopContentDelivery=True
ModSyncTimeoutSeconds=300.0
MaxWorkshopTotalSizeMB=500

Restart the server and connect with a clean game client (one that has not manually copied the mod files). The server sends the Workshop ID, expected size, and SHA-1 checksum. The client downloads the item, verifies integrity, mounts the archive, and only then initiates player spawning:

[Workshop] Player <STEAM_ID> mods ready. Proceeding to spawn.

🧪 12. Server Owner Acceptance Checklist

Before opening your modded server to public players, execute a dual-process test (1 Dedicated Server instance + 1 Clean Client instance) to verify all criteria:

• Client has no pre-existing local copy of the mod PAK.
• Client automatically downloads the correct Workshop ID during pre-login handshake.
• Server logs class resolution and successful mod actor instantiation.
• Client spawn is delayed until synchronization and PAK mounting finish.
• 3D meshes are visible with proper materials and collision geometry.
• Textures render cleanly without fallback checkerboard patterns.
• 3D Audio is audible, spatialized, and attenuates with distance.
• Niagara particle VFX simulate and do not suffer from camera culling glitches.
• Late-joining players immediately see and hear active world props in sync.
• Round restart cleans up previous entities without spawning duplicates.
• Server console shows 0 replication errors or continuous correction spam.

🔄 13. Updating a Published Mod

When releasing a new version or bugfix for your mod, follow this strict update sequence:

🗑️ 14. Disabling or Removing Mods

To safely deactivate a mod from an active dedicated server without causing state corruption:

1. Stop the dedicated server process completely.
2. Either delete the mod folder from SCPReEnter/Mods/<MOD_ID> or set "bIsEnabled": false inside mod.json.
3. Verify that no other active mod lists this mod as a prerequisite dependency.
4. Start the dedicated server again.

🛠️ 15. Common Issues & Troubleshooting

Server cannot find BP_<MOD_ID>

Verify that your EntryActorClass ends with _C (e.g. /Game/Mods/MyMod/BP_MyMod.BP_MyMod_C). Check your PAK listing with UnrealPak.exe <PakFile> -list to confirm the Blueprint was actually cooked into the archive.

Server has collision, but clients cannot see the model

The client's PAK is either missing shader bytecode archives (ShaderArchive-<PROJECT_NAME>-PCD3D_SM5...) or the client is running a different game engine build. Never attempt to fix this by locally spawning actors on the client — this causes immediate network desynchronization.

failed to download required ID <WORKSHOP_ID>

Verify that the Workshop item is published, not deleted, and that the client's Steam account has permission to view it (if set to Friends Only / Private). Detailed download error logs can be inspected in the client's WorkshopRuntime.log.

Client downloads PAK but gets immediately disconnected

The SHA-1 cryptographic hash of the server's local PAK does not match the file downloaded from Steam Workshop. Compare hashes in PowerShell:

Get-FileHash 'W:\Server\SCPReEnter\Mods\MyMod\MyMod.pak' -Algorithm SHA1
Get-FileHash 'W:\Steam\steamapps\workshop\content\4088120\...\MyMod.pak' -Algorithm SHA1

If the hashes differ, re-upload the server's exact PAK file to Steam Workshop or overwrite the server copy with the uploaded file.

Material, Audio, or Niagara effect does not work

Ensure all dependent textures, material instances, audio cues, and emitters are placed inside Content/Mods/<MOD_ID>/. Confirm the cook target was Windows and that the asset path passed to the API node does NOT include /Game/Mods/.

Where to Find Diagnostic Logs

• Server Console & Logs: Dedicated Server standard output and <SERVER_ROOT>\SCPReEnter\Saved\Logs\;
• Client Game Logs: %LOCALAPPDATA%\SCPReEnter\Saved\Logs\SCPReEnter.log;
• Client Workshop Delivery Logs: %LOCALAPPDATA%\SCPReEnter\Saved\Logs\WorkshopRuntime.log.

✅ 16. Final Release Checklist

• Project uses compatible Unreal Engine build (UE 5.7.4) and official SCPModAPI.
• All mod assets are located strictly under Content/Mods/<MOD_ID>/.
• Entry Blueprint inherits from SCP Mod Base Actor.
• All visual and audio logic spawns via Replicated API nodes on the server.
• Content was cooked for the Windows platform target.
• PAK file contains cooked assets AND both PCD3D_SM5 / PCD3D_SM6 shader archives.
• mod.json contains valid ModId, WorkshopId, and _C suffixed EntryActorClass.
• Steam Workshop contains the byte-for-byte identical PAK file used on the server.
• bEnableWorkshopContentDelivery=True is configured in ServerConfig.ini.
• Dual-process verification confirms clean sync and smooth late-joining.