Project Setup Steps

Production context

Verified implementation evidence

• Lambeer.uproject declares EngineAssociation: 5.8.
• Source/Lambeer.Target.cs defines the Windows-capable Game target and Source/LambeerServer.Target.cs defines the Server target.
• .gitattributes routes Unreal binary assets and production-source binaries through Git LFS; git lfs ls-files returns tracked assets.
• The repository has an origin remote. The exact revision for a P00 run must still be selected, committed, pushed and recorded.

Not yet verified: this documentation pass did not prove that the installed engine distribution supports Server targets, that the matching UE 5.8 Linux cross-compile toolchain is valid, that a clean clone builds, or that a packaged Linux server starts. Successful commands and retained logs are the evidence; the existence of target files is not.

Relationships

• PIPE-ROADMAP / ROAD-P00 — owns milestone status and exit acceptance.
• TECH-FOLDER-STRUCTURE
• TECH-STACK-ENGINE
• TECH-SOURCE-STRUCTURE
• TECH-NETWORK-ARCH
• TECH-PERFORMANCE-PROFILING

P00 execution boundary and evidence contract

This runbook explains how to produce evidence for ROAD-P00-02 and ROAD-P00-03. It does not mark either package complete. Run all build commands from a separate clean clone, never from a working tree containing uncommitted production work.

Evidence root: TBD / owner-selected durable location. During a run, use a path outside the repository such as <P00-evidence-root>/<full-commit-SHA>/. Do not commit packaged binaries, generated build directories, secrets or private server configuration merely to satisfy this gate.

Current target contract: the project has Lambeer (TargetType.Game) and LambeerServer (TargetType.Server). No LambeerClient.Target.cs was verified. Use the packaged Lambeer Game target as the Windows client artifact for P00; do not invent a Client target as part of this validation.

ROAD-P00-02 — Clean checkout, LFS and target builds

Goal: prove that a new machine/workspace can obtain one exact remote revision, materialize its LFS objects and build the Windows Game target plus the Linux Server target without depending on files from the current workspace.

1. Approve the immutable input

1. Choose a revision whose required code and assets are committed and pushed. A dirty working tree is not reproducible evidence.
2. Record the full SHA with git rev-parse HEAD. Do not use only a branch name because the branch can move.
3. Record the engine source/installed-build identity separately. EngineAssociation = 5.8 identifies the UE release, but it does not prove which engine binary or source revision built the artifact.

2. Check host prerequisites without installing anything

$p00Engine = '<UE-5.8-root-with-server-support>'
& "$p00Engine\Engine\Build\BatchFiles\RunUAT.bat" Turnkey -command=VerifySdk -platform=Win64
& "$p00Engine\Engine\Build\BatchFiles\RunUAT.bat" Turnkey -command=VerifySdk -platform=Linux

• Both checks must report a valid SDK. Retain the complete output.
• Epic's UE 5.8 dedicated-server workflow requires a source build; an Installed Build is acceptable only if it was explicitly produced with Server and Linux support. If UBT reports that Server targets are unsupported by the engine distribution, stop and prepare the correct engine build instead of changing project code.
• If Linux is invalid, install the matching UE 5.8 Linux x86-64 cross-compile toolchain through the approved Epic/Turnkey workflow, restart the shell if environment variables changed, and rerun the non-installing verification above. The exact toolchain build must come from UE 5.8 requirements, not from an older guide.

3. Create the isolated clone and resolve LFS

$p00Source = 'D:\Unreal Projects\Lambeer 5.8'
$p00Clone = '<empty-validation-directory>\Lambeer'
$p00Sha = '<full-commit-SHA>'
$p00Remote = git -C $p00Source remote get-url origin

git clone --no-checkout $p00Remote $p00Clone
git -C $p00Clone lfs install --local
git -C $p00Clone checkout --detach $p00Sha
git -C $p00Clone lfs pull
git -C $p00Clone lfs fsck
git -C $p00Clone rev-parse HEAD
git -C $p00Clone status --porcelain=v1

The printed SHA must equal $p00Sha, git lfs fsck must succeed, and the final status output must be empty. A tiny text file beginning with the Git LFS pointer header where a binary asset is expected is a failure, not a usable asset.

4. Compile the two existing targets

$p00Project = "$p00Clone\Lambeer.uproject"
$p00Build = "$p00Engine\Engine\Build\BatchFiles\Build.bat"

& $p00Build Lambeer Win64 Development -Project="$p00Project" -WaitMutex
if ($LASTEXITCODE -ne 0) { throw 'Lambeer Win64 Development failed' }

& $p00Build LambeerServer Linux Development -Project="$p00Project" -WaitMutex
if ($LASTEXITCODE -ne 0) { throw 'LambeerServer Linux Development failed' }

Run these in a fresh shell associated with the selected engine. Retain the complete console output and AutomationTool/UnrealBuildTool log paths. Warnings require classification; a zero exit code alone does not waive missing-module, missing-plugin or LFS-related warnings.

5. Record the ROAD-P00-02 result

Do not close ROAD-P00-02 if the build uses uncommitted files, an unrecorded engine build, manually copied LFS assets, a different platform/configuration, or a cached binary produced before the clean checkout.

ROAD-P00-03 — Package, launch and verify two clients

Goal: turn the validated revision into archived Development artifacts, start a headless dedicated server with retained configuration/logs, and obtain an owner-reported two-client connect, movement and disconnect result. A Windows local-server smoke test is useful, but the P00 exit still requires the packaged Linux server check.

1. Cook, stage and archive the Windows Game artifact

$p00Uat = "$p00Engine\Engine\Build\BatchFiles\RunUAT.bat"
$p00Artifacts = '<P00-evidence-root>\<full-commit-SHA>\Artifacts'
$p00Map = '/Game/Lambeer/World/Maps/L_Dev_Sandbox/L_Dev_Sandbox'

& $p00Uat BuildCookRun -project="$p00Project" -nop4 -utf8output `
  -build -cook -stage -pak -archive -archivedirectory="$p00Artifacts\Win64Game" `
  -platform=Win64 -clientconfig=Development -map="$p00Map"
if ($LASTEXITCODE -ne 0) { throw 'Win64 Game package failed' }

2. Cook, stage and archive the Linux dedicated server

& $p00Uat BuildCookRun -project="$p00Project" -nop4 -utf8output `
  -server -noclient -serverplatform=Linux -serverconfig=Development `
  -build -cook -stage -pak -archive -archivedirectory="$p00Artifacts\LinuxServer" `
  -map="$p00Map"
if ($LASTEXITCODE -ne 0) { throw 'Linux dedicated-server package failed' }

Retain both UAT logs and enumerate the archived files. Generate checksums with an approved tool after packaging so the tested artifacts can be identified later. Do not assume the executable's final nested path; locate Lambeer.exe in the Win64 archive and LambeerServer/LambeerServer.sh in the Linux archive, then record the actual paths.

3. Transfer and launch on a representative Linux host

1. Transfer the complete Linux archive without flattening or omitting sibling libraries/content. Verify its checksum after transfer.
2. Place runtime configuration and logs in owner-approved locations outside the immutable package. Never place credentials or production secrets in the evidence bundle.
3. Open the selected UDP game port in the host/network firewall only for the approved test scope. Record the host OS, CPU/RAM, public/private topology and exact port. Do not invent a deployment hostname.
4. Make the discovered server launcher executable and start the explicit development map. Replace placeholders with the paths recorded from the archive:

chmod +x <path-to-LambeerServer-or-launch-script>
<path-to-LambeerServer-or-launch-script> \
  /Game/Lambeer/World/Maps/L_Dev_Sandbox/L_Dev_Sandbox \
  -port=7777 -log -abslog=<P00-evidence-root>/runtime/server.log

The server must remain running, bind the selected port and load the sandbox map without fatal errors or missing cooked packages. If the Linux host uses a service/container, retain the exact wrapper configuration as additional evidence; do not replace the direct executable command with an undocumented service.

4. Owner-only two-client test

User action required: the owner starts and controls both packaged Windows client instances and judges the runtime result. Agents do not perform or claim this test. Use the Linux server address when validating the target package; use 127.0.0.1 only for an explicitly labeled Windows-local diagnostic server.

& '<actual-path-to-Lambeer.exe>' '<server-ip>:7777' -windowed -ResX=960 -ResY=540 `
  -log -abslog='<P00-evidence-root>\runtime\client1.log'

& '<actual-path-to-Lambeer.exe>' '<server-ip>:7777' -windowed -ResX=960 -ResY=540 `
  -log -abslog='<P00-evidence-root>\runtime\client2.log'

1. Wait until both clients finish loading the same server map. Record server-log evidence for two accepted connections.
2. On client 1, move and rotate while observing client 2. On client 2, move and rotate while observing client 1. Record whether each remote representation updates and whether either client is corrected, frozen or disconnected.
3. Close client 2 normally. Confirm the server remains running and records the disconnect; confirm client 1 remains connected and can still move.
4. Reconnect client 2 once if the current game flow permits it. If character/session entry is not implemented enough to reconnect, record that limitation; do not convert it into a pass.
5. Close client 1, then stop the server gracefully. Preserve server and both client logs before deleting any temporary runtime directory.

5. Acceptance record

Do not close ROAD-P00-03 from Editor PIE alone, from a Windows local server alone, from one connected client, or without the retained Linux package and runtime logs.

Failure routing and rerun rule

Rerun rule: any source, content, target, plugin or packaging-configuration change creates a new revision. Restart from the clean-clone step and keep the failed evidence alongside the rerun; do not splice logs from different SHAs into one apparent pass.

Primary external references: Epic — Setting Up Dedicated Servers (UE 5.8), Epic — Build Operations (UE 5.8), and Epic — UBT Target Reference (UE 5.8). These links are references only; this page remains usable offline.