Start here

↑ ↓ to move, Enter to openKeyword search
Multiplayer

Pelican Warfare prototype

Rendered from the repository, where it is written as the work happens: it keeps its history, and a status line above says when it describes a design rather than something shipped.

PWR uses the existing Blam simulation and native Megalo interpreter. Unreal renders the authored map, objective fields and cosmetic parachute. Lua stages the mode, handles a Space key event and presents a bounded native snapshot; it does not implement movement, captures, respawns, scoring or match timers.

Current alpine expansion

The v5 world has a 2 × 2 km playable terrain with three Forerunner sites, connected vehicle roads, four crossings, a descending river and a lake. Its surrounding 8 km mountain field is a render-only backdrop. The gameplay area has not expanded to 8 km. Gaea supplies eroded terrain; Unreal Landscape, Nanite scenery and baked PCG instances render it. Blam retains authoritative collision, vehicles and the native Warfare rules.

The current visual build uses levels/warfare/pwr/upgrade-v5-visual5.json and the isolated world-v5-visual5 conversion. Its forest contains 4,470 trees, 804 rocks and 279,388 grass instances. Water uses native Fluid Flux surfaces and saved flow/depth/foam states; this is baked playback, not a map-wide real-time fluid simulation. See water integration, surface materials, mature pine and terrain preservation for their build contracts.

The original basin commands and acceptance history below describe the first prototype. Do not apply its prepare_runtime.py step to the expansion: the expansion uses refresh_native_probes.py with vehicle-spawn-policy-v1.json to preserve verified vehicle spawn heights and bind probes to the newly compiled collision. Local installation receipts and fresh native acceptance evidence live under out/pwr/world-v5.

Play the installed preview

Select map PWR / Pelican Warfare and mode PELICAN WARFARE in the MJOLNIR lobby, then start a private match. The installed preview starts with one player after a five-second warmup. Press Space to leave the Pelican and again to deploy the parachute; automatic exit and deployment are fallbacks. Stand on A, B or C on foot for eight seconds to capture a neutral site. Owned uncontested sites score once per second. Death returns you to your team base after five seconds; the target is 500 control points.

Rules and build

mjolnir megalo write --mode warfare --vehicle-label-pool --out warfare.mglo builds the variant. Install it in MJOLNIRLevelLoader/variants/warfare.mglo. The bundled mode_descriptors.lua registers the mode only for PWR and shares its lobby, loader and scoreboard metadata. The installed variant controls the score threshold; persisted settings from another mode cannot change it. Warfare opts into a same-mode postgame rotation on its supported maps. With only PWR installed, no ballots replay PWR Warfare; LOBBY returns to manual map/mode selection. Other modes retain the existing mixed-map, mixed-mode vote.

Defaults are two connected players, 30 seconds of warmup, 60 seconds of insertion, first to 500 control points, or 20 minutes of combat. The three neutral koth_hill markers use spawn sequences 0, 1 and 2, matching the three koth_hills entries in level.json. Living players on foot capture; vehicle occupants do not. One side alone takes a neutral site in eight seconds; changing an enemy site takes eight seconds to neutralize and eight more to capture. Extra teammates do not accelerate capture. Opposing presence stops capture and scoring. An owned empty site continues to earn one point per second. Kills do not score. Each death respawns the player at their permanent Red or Blue home after five seconds, with unlimited lives and no suicide/betrayal delay. These are individual respawns, not waves.

CLI flags allow explicit development variants: --minimum-players, --warmup-seconds, --insertion-seconds, --capture-seconds, --warfare-minutes and --score. The lobby's fixed settings describe the shipped defaults; development timing variants are not editable lobby rules.

Original basin build and installation

Run these commands from the repository root in PowerShell 7. They require the project's existing Rust/MSVC, Python, Blender, HEK and Unreal 5.5 toolchains. The commands use the Steam install and the PWR conversion/work directories in levels/warfare/pwr/upgrade.json; change those explicit paths for another installation. See the PWR source README for the isolated HEK build and initial CE conversion that produce pwr.level.json.

Build the CLI, the map/canopy helper executables and both native DLLs:

cargo build --release -p blam-cli
cargo build --release -p ue-asset --examples
cargo build --release -p blam-pack --examples
cargo build --release -p ue-iostore --example extract_file
pwsh -NoProfile -File native/lobby/build.ps1
pwsh -NoProfile -File native/map_registry/build.ps1
$env:MJOLNIR = (Resolve-Path target/release/mjolnir.exe).Path
$env:EXAMPLES = (Resolve-Path target/release/examples).Path

The ue-asset examples include mesh_rewrite and retarget_package; the blam-pack examples include package_add and native_material_clone. extract_file belongs to ue-iostore. Keep both environment variables set in the PowerShell session used below: the bake stage otherwise defaults to an older server-list worktree CLI and C:/haloce/target/debug/examples, which can silently mix tools from different checkouts. Reapply these assignments when resuming a stage in a fresh terminal.

The map-registry build also rebuilds and links mjolnir-mglo-cabi. It must match the variant grammar in this checkout. Replacing only the Lobby DLL leaves the installed map-registry staging validator at its old version.

Build the Pelican and original canopy into staging directories, then patch, cook and assemble the map's private visual upgrade:

$pwrGame = 'C:\Program Files (x86)\Steam\steamapps\common\Halo Campaign Evolved'
$pwrPaks = Join-Path $pwrGame 'Meteorite\Content\Paks'
pwsh -NoProfile -File tools/level/build_warfare_pelican.ps1 -Paks $pwrPaks -OutDir out/pwr/pelican
python levels/warfare/pwr/canopy/build.py --paks $pwrPaks --preview
python levels/warfare/pwr/prepare_runtime.py --level C:/haloce/ce_conversions/warfare/PWR/converted/pwr.level.json
python levels/warfare/pwr/upgrade.py --stages land,foliage,swap,collision
python levels/warfare/pwr/upgrade.py --stages editor,cook,bake,assemble

Current private container assignments are canopy 964, landscape 965 and Pelican 971. The runtime installer takes the generated container names; it does not hard-code a stale chunk number. Preserve the map's capture markers, permanent team spawns and named flags when rebaking.

Close the game before installing. The map install is local and creates no hub listing. The runtime installer copies the complete Loader, Lobby and HUD Scripts trees, both native DLLs, the variant plus its layout and the staged Pelican/canopy containers. This is a single compatible runtime: copying only the new Warfare scripts onto an older release can leave missing helper APIs.

python levels/warfare/pwr/upgrade.py --stages install --local-install
pwsh -NoProfile -File levels/warfare/pwr/install_runtime.ps1 -Game $pwrGame -SoloPreview

-SoloPreview builds a one-player, five-second warmup variant for the private test. Omit that flag to restore the normal two-player, 30-second warmup. The user's current local installation uses -SoloPreview with the default 500-point target, recorded in out/pwr/runtime-20261108-224928/install-receipt.json. The five-point variants below were acceptance-test artifacts, not the final installed score limit. The installer writes out/pwr/runtime-<timestamp>/install-receipt.json and backs up each replaced runtime file before copying it. Standalone variant generation and validation, without installation, are:

New-Item -ItemType Directory -Force out/pwr/variants | Out-Null
target/release/mjolnir.exe megalo write --mode warfare --vehicle-label-pool --out out/pwr/variants/warfare.mglo
target/release/mjolnir.exe megalo validate out/pwr/variants/warfare.mglo
target/release/mjolnir.exe megalo read out/pwr/variants/warfare.mglo

Launch and sign in at the frontend, then explicitly host a private PWR test:

node tools/mcp/game/cli.mjs launch
node native/lobby/smoke-warfare.mjs --host --jump --respawn --capture-a --seconds=90

The probe waits for frontend sign-in and requests host PWR warfare private. Its explicit flags request jump/deployment, kill the landed test player once to verify respawn, and teleport that player to capture A. It writes JSONL evidence under out/pwr/. To observe an already running match without those actions, use node native/lobby/smoke-warfare.mjs --seconds=50.

After insertion, node native/lobby/smoke-warfare-vehicles.mjs --drive --screenshots checks a private active layout-2 match with exactly one local player, then boards the home fleet's Warthog, Scorpion and Banshee through the installed probe volumes. It verifies each actual salted vehicle parent before four bounded one-second W inputs and records body displacement and player/vehicle health. --team=blue selects the other fleet; --seconds=3..5 adjusts total input time. --banshee-ascend additionally holds Space and requires upward displacement; that input binding still needs a live check. The harness leaves the final Banshee occupied, does not end the match, and makes no game calls without --drive. JSONL evidence and optional screenshots go to out/pwr/.

Native bridge and presentation

The loader requires level metadata warfare: {protocol: 20568, layout_revision: 2} and opens MJOLNIRLobby/native/mjolnir_lobby.dll with a configuration containing warfare-config 2, map PWR, layout 2 and protocol 20568. Its four exported Lua entrypoints are mjolnir_warfare_open, close, action and pump (all with the mjolnir_warfare_ prefix). Space sends only a jump/deploy request. The native adapter validates the simulation build, scenario, engine, instance, Megalo protocol and the four baked flight endpoint positions before acting. The endpoint check rejects an old PWR scenario even if its JSON was updated. Movement remains on the owning simulation peer; the host controls the named transports. Late joins and subsequent respawns use the home bases rather than repeating insertion.

Global number slots are phase 0, phase age in ticks 1, protocol magic 20568 at 2, deployment duration / combat elapsed seconds 3, connected count 4, scratch 5–6, Red/Blue score 7–8 and A/B/C site states 9–11. Phases are warmup 0, insertion 1, combat 2 and complete 3. A site state packs `owner + 4 × (red present + 2 × blue present)

  • 16 × (progress + 17): owner neutral 0, Red 1, Blue 2 in the low two bits, and capture progress in sixteenths toward Red (+16) or Blue (−16), counted against thresholds fixed when the variant is built (SiteStateinwarfare.rs`). Steps, not ticks, keep the replicated value from changing every tick. A value under 16 is an owner alone (older variants, or before combat). Slot 3 publishes the configured insertion duration in phases 0–1, then resets to zero and counts combat seconds in phase 2. Phase, age, magic, duration/clock, scores and owners have high replication priority, connected count low priority, and scratch remains local. Native code reads this state; Megalo owns it. An absent team's native score operand is -1 in the supported build; the published score mirror clamps that sentinel to zero without creating or changing the absent team's engine score.

levels/warfare/pwr/layout.json generates native/lobby/warfare_layout.h. The native build regenerates it; the portable test runner rejects stale output. Layout 2 uses a 2 km scenario, a ±950 m play area and 240 m flight altitude. The host projects desired world velocity into the verified full 3D vehicle axes, corrects bounded route/altitude error and caps speed at 30 m/s. Default automatic exit occurs at 54 of 60 seconds; explicit development durations scale the exit time without exceeding that speed cap. Descent has a 90-second timeout and accepts settled landings at any height inside the play volume. Slopes keep the canopy state until vertical movement settles. These expansion changes require live validation independently of the smaller prototype's successful insertion tests recorded below.

The loader publishes MJOLNIRLobby/native/warfare_state.txt every 500 ms; the HUD reads at the same interval. The warfare-state 2 format includes layout revision and configured insertion duration. The HUD checks the complete format, ready/status flags, mirrored globals, exact uint64 instance text and current PWR world. Two advancing tick/time samples are required before accepting a file or a new instance. Live samples expire after two seconds without advancing; a verified final snapshot remains usable during stopped postgame and the engine's brief same-instance round reset before lobby travel. Malformed or stale files cannot change score. Team CONTROL totals and the winner come from accepted native scores, never summed player incidents. Individual control cells show a dash; kills and deaths remain visible. Final standings allow 1.5 seconds for the final publication to arrive.

The status line gives warmup, boarding, Space-to-jump, exiting, Space-to-deploy, canopy, landing/active and failed-deployment information. During combat it gives way to three zone tiles under the score (WBP_MJOLNIRWarfareZones, chunk 958 beside the tactical map, filled by warfare_zones.lua): owner colour, NEUTRAL / RED / BLUE / CAPTURING / NEUTRALIZING / CONTESTED, the capture bar, a pip for each team standing in the zone and a gold rim on the zone the local player stands in. A site changing hands puts "Red team captured zone B" (or "… neutralized zone B") in the kill feed on every client from its own snapshot. Three fixed holographic fields and A/B/C waypoints still mark the sites in the world. Contest and progress come from Megalo's published site state, never from rendered positions.

warfare_canopy.lua uses the original /Game/MJOLNIR/Maps/PWR/SM_PWR_Parachute.SM_PWR_Parachute mesh, a 274.4 cm relative Z offset and uniform scale 4.1166 from the canopy build metadata. It disables collision and shadows and attaches once to an existing validated cached biped. Unreal follows the attachment without a Lua movement loop. Only native stage 4 displays it; landing, death, missing/stale state and map exit hide it. Native drop stages currently exist for owning local players, so remote canopy visibility needs a verified replicated stage channel before it can be claimed. The cosmetic asset is optional for gameplay.

Validation and remaining runtime checks

The private solo acceptance run passed all seven recorded milestones: native bridge ready, Pelican seated, canopy deployed, landed, respawned, site scoring and round ended. The local receipt is out/pwr/smoke-2026-11-09T05-27-03-197Z.jsonl. It used a short test variant with a five-point target; the verified terminal snapshot has phase 3, Red 5–Blue 0 and capture A owned by Red. Screenshot events include seated, canopy, landed and end; the final screen showed Red winning 5–0. The tested native DLL SHA-256 is 4073f89c8d51bbf7229e7571613fdb0b79ef12a87bb533c5e200d2b3e8fa8068. The earlier absent-team -1 score sentinel is now covered by the publishing clamp and a behavioral regression test.

A subsequent private test with two local player slots also passed, recorded in out/pwr/smoke-2026-11-09T05-30-30-841Z.jsonl. Red player 0 and Blue player 1 boarded their respective transports, exited automatically, deployed canopies and landed. Native landing positions in metres were Red (172.518, -62.345, 0.244) and Blue (-176.537, 64.270, 0.588). Red then died, respawned, captured A and won the short five-point test 5–0. Both slots ran in one local game process; this establishes the local two-team transport flow, not remote networking.

After the spawn-palette correction, the installed 500-point solo variant passed the keyboard and transport-lifecycle run in out/pwr/smoke-2026-11-09T05-46-27-499Z.jsonl. It observed ready, seated, canopy, landing, respawn and scoring, plus early exit from an actual Space key input. Named transport counts were zero in warmup, two during insertion and zero after cleanup. This used the 4073f89c... native DLL above. No round end was expected during this short 500-point run; the earlier five-point tests cover that transition.

A live visual comparison found that passenger seat pelican_p_l04 avoids the large gray polygons visible from pelican_p_l01. The native boarding order now prefers l04, l05, r04, r05, l01, l02, l03, r01, r02, r03, retaining all ten passenger seats. Only l04's view has been visually verified; the other nine seats have not been visually certified. The updated native DLL build and portable tests passed with SHA-256 498aa411f354124f9a79ab7f48d5c08f97acd960eb88510c5c2194340200624b. That DLL is in the latest installation receipt above. Its final private live run passed in out/pwr/smoke-2026-11-09T05-50-20-538Z.jsonl: ready, seated, canopy, landing, death/respawn, capture scoring, actual Space exit before the automatic fallback, and transport counts 0 / 2 / 0. The in-flight seated screenshot confirms the improved l04 view. This 90-second run retained the installed 500-point target and did not require a match end; the earlier five-point runs separately verified victory.

cargo test -p blam-megalo --lib --test warfare_behavior validates typed and independent grammar roundtrips plus deterministic warmup, capture, contested scoring, on-foot eligibility and victory behavior. Lua tests test_warfare_bootstrap.lua, test_warfare_hud.lua and test_warfare_canopy.lua cover bootstrap, freshness, score authority, persisted settings, presentation and canopy attachment lifecycle. test_lobby_postgame.lua covers the scoped Warfare rotation and the unchanged ordinary rotation. The latest Warfare-only postgame rotation has been unit tested but has not yet been verified in a live postgame vote. The HUD regression preserves a verified terminal result when the engine starts resetting its round before frontend travel.

Integration is ongoing. Remote host/client replication, remote seating and drop, remote canopy visibility, join-in-progress, a full 16-player match, full vehicle combat remain unverified. Opposing teams contesting a capture site is covered by the deterministic VM tests, not a live contested-site test. The historical runs above used the original 400 × 300 metre basin; they do not certify the current expansion's terrain, scenery or performance. The expansion requires its own installed-build checks. No increased player cap or third team is implemented.