Nebula Local Resync

Nebula Local Resync is a targeted recovery utility for Dyson Sphere Program multiplayer sessions using Nebula Multiplayer Mod. It allows a connected client to request a fresh, host-authoritative snapshot of the factory area around the local mech and repair supported component state without forcing a full reconnect or reloading the entire planet.

The same mod must be installed on both the Nebula client and the Nebula host/server. Headless Nebula servers are supported because the server and client use the same BepInEx plugin; the plugin determines its multiplayer role at runtime.

Current status: Alpha. The mod is intentionally conservative. It repairs supported component state but does not create or delete structurally mismatched factory entities.

Why use it?

Long-running multiplayer sessions can occasionally leave a client with factory state that no longer matches the host. Symptoms may include local machine state appearing stale or inconsistent even though the host still has the authoritative simulation state.

Nebula Local Resync provides a bounded recovery operation centered on the player instead of immediately requiring a disconnect/reconnect cycle.

Usage

While connected to a Nebula host and standing on a loaded planet, press:

Ctrl + Shift + R

The client requests a resync around the local mech. The default audit/resync radius is 150 meters.

The host builds the authoritative response and sends it only to the requesting client. The response is validated and applied on the Unity game thread.

What is currently repaired

Version 0.1.2 can refresh supported state for matching nearby factory components, including:

• Storage components
• Assemblers
• Miners
• Labs

The operation also audits nearby entity topology and records discrepancies such as:

• Entities present on the host but missing locally
• Entities present locally but absent on the host
• Entity/prototype mismatches
• Nearby belts

Intentional limitations

Nebula Local Resync is designed to avoid destructive recovery operations while the player is actively standing on a planet.

In this version:

• Missing or phantom buildings are reported but not created or deleted.
• Structurally mismatched entities are reported but not replaced.
• Belt entities are audited, but belt cargo-path contents are not rewritten.
• The mod does not tear down and reload the active PlanetFactory beneath the player.
• If structural desync remains after a local resync, Nebula's normal reconnect flow remains the appropriate fallback.

These restrictions are deliberate. The goal is to repair supported state without introducing a second desync through aggressive live-factory reconstruction.

Installation

r2modman / Thunderstore Mod Manager

Install the package normally and allow the mod manager to install its dependencies.

Install the same version of Nebula Local Resync on both the client and the host/server.

For a remote headless server managed separately, install/copy the same package DLL into that server's active BepInEx profile.

Manual installation

Install the required Nebula/BepInEx stack first, then place:

NebulaLocalResync.dll

under:

BepInEx/plugins/NebulaLocalResync/

on both the client and host/server.

Restart both instances after installing or updating the mod.

Configuration

A BepInEx configuration file is generated after the first launch:

BepInEx/config/com.local.nebulalocalresync.cfg

Configuration includes the client resync hotkey and radius as well as server-side safety limits such as maximum radius, maximum entity count, maximum payload size, and request cooldown.

Server-side limits are enforced by the host even when a client requests a larger operation.

Safety and networking model

• The host remains authoritative.
• Clients request repair data; they do not dictate authoritative factory state.
• Resync requests are radius-bounded and server-limited.
• Oversized requests are rejected instead of silently truncating the authoritative snapshot.
• Factory state application is queued to the Unity game thread rather than performed directly from a network callback.
• Structural differences are surfaced rather than automatically creating/deleting live factory entities.

Troubleshooting

If the hotkey does not produce a resync:

1. Confirm the same version of Nebula Local Resync is installed on both client and server.
2. Confirm both sides are running compatible versions of Dyson Sphere Program and Nebula.
3. Check BepInEx/LogOutput.log on both client and server for entries containing Nebula Local Resync or Nebula Resync.
4. Confirm the client is connected and standing on a loaded planet.

If the resync completes but reports missing, phantom, or mismatched entities, those structural discrepancies are not modified by version 0.1.2. Use Nebula's normal reconnect flow if the visible desync persists.

Requirements

• Dyson Sphere Program
• BepInEx
• Nebula Multiplayer Mod

The Thunderstore package declares Nebula Multiplayer Mod as a dependency so its required dependency chain is installed by supported mod managers.

Changelog

0.1.4

• Changed Thunderstore/r2modman packaging to place the plugin DLL directly at the package root so the mod manager owns deployment into the active BepInEx profile.
• Removed all automatic/manual profile installation behavior from the build script. Building now compiles and packages only.
• Added explicit package validation and output messaging so a successful build confirms the upload ZIP contains the compiled DLL and required public files.
• No resync protocol or gameplay behavior changes from 0.1.3.

0.1.3

• Adds host-authoritative Dark Fog ground-enemy reconciliation.
• Fixes the client failure mode where a Dark Fog enemy can remain visibly rendered but become untargetable after combat synchronization diverges.
• Host now includes a planet-wide active ground-enemy ID set plus nearby enemy identity/position data in the resync snapshot.
• Removes nearby client-only phantom Dark Fog enemies only when the host confirms the enemy ID is absent from the entire planet.
• Repairs Nebula's transient pending/invincible enemy flags when the host confirms the enemy is still alive nearby.
• Performs enemy removal through DSP's normal RemoveEnemyFinal cleanup path while inside Nebula's incoming-combat scope.
• Reports authoritative host enemies that are completely missing locally instead of attempting unsafe partial recreation.
• Adds Server.MaximumGroundEnemiesPerPlanet as a safety bound.
• Bumps the custom snapshot protocol to version 2; client and server must both run 0.1.3.
• Build script now validates the project-root 256x256 icon.png and emits a complete, directly uploadable Thunderstore ZIP with all public package files.

0.1.2

• Fixes compilation against current DSP/Nebula assemblies that target .NET Standard 2.1 by explicitly resolving and referencing netstandard.dll.
• Adds available Unity/DSP .NET Standard facade assemblies to the PowerShell compiler reference set.
• Prints the selected netstandard.dll path before compiling so the active reference can be verified from the console output.

0.1.1

• Fixes a PowerShell parser error in Build-And-Install.ps1 caused by interpolating $Root: without braces.
• Clarifies the remote-server workflow: build once locally, then copy the same DLL to the remote server.

0.1.0

• Adds a client-requested, host-authoritative local factory resync.
• Default activation is Ctrl+Shift+R on a connected client standing on a loaded planet.
• Host scans a bounded radius around the request position and returns an authoritative entity manifest.
• Matching storage components are serialized with DSP's own Export/Import methods.
• Matching assembler, miner, and lab components receive primitive/primitive-array state from the host.
• Host/client topology differences are detected and logged but are not created or deleted.
• Belts are included in the topology audit; belt cargo-path contents are deliberately not rewritten in this release.
• Packet processing queues all DSP reads/writes onto Unity's game thread.