The companion MCC implementation adds an independent loader for modern Halo 1 MCC version-13 caches and MCC SINGLEPLAYER / MCC MULTIPLAYER choices in the map menus. It is an experimental runtime adapter, with explicit format limits below. A successful menu probe or file audit is not proof that a map plays correctly.
This document describes the MCC map format the port reads, how the implementation is laid out and what it does not support. Its notes on particular maps describe the maps examined during development; they are not a guarantee for every map. The reading guide follows the implementation through the sources.
MCC map conversion displays OpenCE's original animated loading effect. Its
progress follows resource checks, conversion and validation, then initial
scenario setup. It represents completed work, not a time estimate. Long audio
and texture operations refresh the display between bounded pieces of work;
a single blocking read or allocation can still pause it briefly. A refused
map closes the effect and shows its package/level and the failed check. Missing
or incompatible resources name the resource file and where to install the
matching MCC copy. Unsupported script names and conversion stages are reported
when known; debug.txt retains the detailed checks. The existing menu return
and network-session abort behaviour is unchanged.
The screen uses the Xbox installation's maps/loading.tga imported from the
disc image. If that file is missing, the original renderer has no loading
picture to show. Lobby/catalog checks before loading are unchanged. The effect
does not run gameplay or alter network readiness, authority or map validation.
The loading presentation setting also applies to MCC conversion: widescreen is on by default, and turning it off restores the central 4:3 framing. The original mask and effects remain, and the Xbox chant stops when loading finishes or fails. PC Settings > Video > Graphics exposes the toggle, including through the PC pause menu; Xbox menus are unchanged.
OpenCE's stock selector offers MCC singleplayer and multiplayer categories, package folders, campaign difficulty selection, previews and completion badges. The same menu runs on every platform. See MCC menu images and badges for metadata and completion-record limits. Fork-specific Modern and Xbox-style menus are not part of this upstream contribution.
Put the map in the game data root's mcc_maps directory, beside maps and
custom_maps. For example:
maps/ Xbox game data
custom_maps/ Halo Custom Edition data
mcc_maps/a10.map Halo 1 MCC custom map
mcc_maps/a10.txt Optional plain-text description
mcc_maps/sounds.map Matching MCC resources, when required by the package
mcc_maps/bitmaps.map Matching MCC resources, when required by the package
You can also copy an entire downloaded Halo 1 Workshop folder from
steamapps/workshop/content/976730/<item id> into mcc_maps/<item id>.
Leave its maps, metadata, images and halo1/maps resource folders intact.
Local discovery does not require Steam or the Steam Discovery setting.
The menu reads the package title from ModInfo.json and level names and PNG
previews from the referenced metadata. Missing metadata retains the normal
filename labels and placeholder image; a numeric package without a title
shows "MCC package". Unsupported or damaged images also use the placeholder.
Both disk layouts use mcc_maps\<package>\<level> internally. Local lookup
prefers a file directly in the package, then the same file in maps; for
bitmaps.map and sounds.map, it also checks the package's halo1/maps.
A present invalid direct file is not replaced by a nested or Steam copy.
Nested lookup rejects linked paths and special files. It searches only these
fixed locations, never arbitrary subdirectories or other packages. Manual
folders containing only level files remain valid. Copying a package does
not supply missing shared base resources; the existing resource requirements
and automatic sharing policy still apply.
The level identity is mcc_maps\a10. The filename is retained even when
the internal scenario name differs. The supplied Mercury Rising file is
an example: its filename is a10.map, while its header names
mercury_falling. The namespaces prevent it replacing either Xbox a10
or Custom Edition custom_maps\a10.
Some campaigns keep audio and textures in separate resource files. For manual packages, keep each package's supplied files beside its levels. With desktop Workshop discovery enabled, packaged and installed MCC resources are found in place as described below. For installations without Steam discovery, install MCC's two standard sets once:
mcc_maps/_shared/singleplayer/bitmaps.map
mcc_maps/_shared/multiplayer/bitmaps.map
mcc_maps/_shared/multiplayer/sounds.map
mcc_maps/solar_flare/m0.map
mcc_maps/solar_flare/m1.map
mcc_maps/solar_flare/sounds.map
mcc_maps/solar_flare/bitmaps.map
Copy the singleplayer file from MCC's halo1/maps/bitmaps.map. Copy the
multiplayer files from MCC's halo1/maps/custom_edition/. Both must come
from MCC; do not substitute a Custom Edition installation. These folder names
are installation labels, not a restriction on the maps that can use them.
_shared is not a level package and its nested resource folders are not menus.
Selection is independent for bitmaps and sounds. A package resource is
selected first, then a legacy mcc_maps/bitmaps.map or sounds.map if present.
These explicit overrides are authoritative: unreadable, damaged or incompatible
files fail rather than being silently replaced. If neither exists, every
external reference of that type is checked against each installed shared set.
A complete matching file is required; partial matches are never combined.
Two complete but different matching files are ambiguous: put the intended file
beside the level. Byte-identical matches are interchangeable.
Self-contained levels do not open or fingerprint resources. Only required types
are considered. Chosen paths and failures are logged in debug.txt. The MCC resource reader
uses bitmaps.map and sounds.map, not CE's localization resource loc.map.
Native MCC maps carry their localization tags within the level; MCC's editing
kit does not use loc.map except for Custom Edition backwards compatibility
(editing-kit format notes). Android and
browser package importers can retain a bundled loc.map, but the MCC runtime
does not consume it. Custom Edition retains its own loc.map support.
Nothing searches other packages, maps or custom_maps.
A package level's identity is mcc_maps\solar_flare\m0.
Network peers may use different package folder names; the level filename and
complete map/required resource contents must match the host. Optional
.txt descriptions remain beside the corresponding level. No manifest is
required.
A package from the Steam Workshop can say which item it is, so a joiner who
cannot match the host's map is told what to do. The item is a workshop_id.txt
in the folder (the id on the first line and, optionally, the title on the
second), or the package folder when Steam's own name (the item id, all digits)
is kept, or else the ModIdentifier.HostedModIds.SteamWorkshopId that MCC's
tools write into the package's ModInfo.json (a number or a string, not 0, with
Title.Neutral as its title), so a package copied in under a name of its own
is still known. The host sends the id and title in the map name's reserved tail
(mcc_workshop.c). The original fork introduced this advisory extension under
MCC protocol 64. The upstream contribution uses one shared OpenCE protocol, 42,
including MCC content/metadata digests and checkpoint lifetime fencing; see the
wire contract.
The item is advisory: the level filename and content fingerprint still decide
admission. A known local item is recognized even if its older package lacks
the requested level. A matching filename without an item id does not prove
the item is installed. The refusal distinguishes an identified package that
does not match from a package that cannot be identified locally. Both messages
name the item and tell the player to copy the host's matching map and required
resources into mcc_maps; a map with no item id gets the fingerprint text,
naming the level file. A mismatch does not establish which player's copy is
newer. This advisory identity does not itself discover Steam libraries or synchronize
manually copied packages. Desktop discovery uses the separate Workshop catalog
integration described next.
Installed packages can also supply level previews.
Keep their listed map/mission metadata and PNGs together. Stock menu panels use Images.Large, then Images.Thumbnail, with
the question mark as fallback. Pictures fit and clip to the existing thumbnail
rectangle, and MCC titles/descriptions wrap within their text boxes. This also
works for complete Android imports without Steam and does not enable sharing.
With game.workshop_maps = true (the default; HALO_WORKSHOP_MAPS=1), desktop
builds list Halo CE maps from the Workshop items a player is subscribed to
without copying anything into the data root. steam_workshop.c looks in Steam's
libraries for steamapps/workshop/content/976730/<item id>/: the usual Steam
folders (on Windows %ProgramFiles(x86)%\Steam; on Linux ~/.steam/steam,
~/.local/share/Steam, and the Flatpak and Snap places), the paths.steam
setting (HALO_STEAM_ROOT), and every library their libraryfolders.vdf
names. On Windows it also reads SteamPath from the current user's
Software\Valve\Steam registry key and InstallPath from both the 32-bit and
64-bit machine-wide views of that key. Thus an installation such as C:\Steam
is discovered without editing the configuration or running Steam. The manual
paths.steam root is checked first, followed by registered installations and
standard folders; its copy of a duplicate item takes precedence. Missing,
unreadable, non-string or oversized registry values are ignored. The detected
path is not written to the configuration: an empty setting continues to use
automatic discovery on the next scan.
On Linux, after the manual override, discovery checks the literal absolute path
in STEAM_COMPAT_CLIENT_INSTALL_PATH when the launch environment supplies it,
then $XDG_DATA_HOME/Steam. It also keeps the home-folder fallbacks above and
adds ~/.steam/debian-installation. The existing ~/.steam/steam and
~/.steam/root links can point to an installation anywhere the user can read;
each discovered root's library list can locate libraries on other drives.
For example, XDG_DATA_HOME=/mnt/data/player finds
/mnt/data/player/Steam with paths.steam empty. Missing, stale, relative,
control-character or oversized environment hints do not prevent fallback
discovery. Paths are not expanded as shell expressions or written to config.
The location evidence is the XDG base-directory specification,
Valve's use of the client-install hint in Proton's launcher,
and the Valve maintainer's description of Debian's installation folder.
These are discovery hints, not an exhaustive drive search. An installation with
no accessible hint, link or known location still needs paths.steam; sandbox
filesystem permissions can also prevent discovery.
An item is used when its ModInfo.json says "Engine": "Halo1"; each
path in GameModContents.MultiplayerMaps is a map json whose ScenarioFile
names the .map file in the item's maps folder, whose Title.Neutral is the
map's title and whose Images.Thumbnail is its preview picture. Folder names
inside an item are found without regard to case, as Steam's files are spelled
by their makers. An item seen through two paths to one library is listed once.
A multiplayer item may list up to 1,024 maps, matching the existing total Workshop catalog capacity. The former 64-entry item limit rejected whole collections, including an inspected 75-entry Halo 1 package; it was a reader capacity, not an MCC format restriction. The reader validates every listed path and retains the 256 KiB JSON limit. Larger lists are refused with a diagnostic naming the package title, entry count and supported limit. The combined catalog still holds at most 1,024 maps across all packages. Campaign progression retains its independent 64-mission limit.
tools/test_steam_workshop.py exercises 64/65/75/1,024-entry manifests,
unrelated package identities, late malformed paths, catalog saturation and
disable/re-enable/rescan behavior through the real reader and discovery code.
Local menu metadata and previews use the same multiplayer bound, including
Android/web packages; tools/test_mcc_previews.py checks titles and images
from entries beyond the old limit. Discovery does not establish that every
map's gameplay content is supported.
Discovery defaults to off. Android and web use installed mcc_maps packages;
they do not search for Steam. Local package folders take precedence regardless
of their letter case. The path translation hook is necessary because the shared
file reader opens virtual Xbox paths; it handles only mcc_maps requests and
leaves maps and custom_maps on their established paths.
Each map is the level mcc_maps\<item id>\<map name>, so it is the same
package identity as a folder named by the item id (above), and the host's item
id and title and a joiner's refusal text work as for any such package. The path
translation (platform_translate_path) opens mcc_maps\<item id>\ as the
item's maps folder in Steam's library. A package folder of that name in the
data root's mcc_maps wins, so a player can still override an item by hand.
The MCC menus show the map's Workshop title, and a package folder shows the
item's title instead of its id. The resources a map needs (bitmaps.map,
sounds.map) are selected independently. A Workshop resource beside the level
in the item's maps folder takes precedence; when absent, the same item's
halo1/maps file is used. An existing entry remains authoritative even if it
is damaged or unreadable. Nothing borrows another Workshop item's resources.
A local mcc_maps/<item id> package also prevents borrowing that item's files.
If package and legacy root resources are absent, the existing shared-set
selection checks both standard sets. A manually installed file under
mcc_maps/_shared wins. Otherwise, with Workshop discovery enabled, each set
resolves in the first discovered Steam library containing the corresponding
MCC file, under steamapps/common/Halo The Master Chief Collection/:
halo1/maps/bitmaps.mapfor the singleplayer set;halo1/maps/custom_edition/bitmaps.mapandsounds.mapfor the multiplayer set.
These are MCC installation directories, not the separate Custom Edition game
or the data root's custom_maps. The setting's existing library order applies;
libraryfolders.vdf includes installations on other drives. Disabling discovery
keeps manually installed package/root/shared paths. Android and web retain
installed/imported packages and do not search Steam.
Discovery only supplies paths. mcc_resources_select still validates the file
and every external reference, rejects partial matches and ambiguous different
matching shared files, and fingerprints the selected bytes rather than their
location. Self-contained maps open no unrelated resources. Selected streams
are owned by the current MCC runtime and closed on unload or failed loading.
No map names, checksums or Workshop-ID exceptions select this behavior.
The layout evidence is the installed Halo 1 MCC shared directories and multiple
Workshop items with authored resources under halo1/maps. Their metadata can
say HasSharedFiles: false while those files are present, so discovery uses the
bounded, conventional resource paths and the reader validates the contents;
that metadata flag does not override an installed package resource. The synthetic
regressions in tools/test_steam_workshop.py exercise unrelated item identities,
case-insensitive paths, overrides, missing types, library roots and bounds.
tools/test_mcc_resources.py checks complete-reference matching, ambiguity,
malformed resources, independent bitmap/sound selection and content identity.
The catalog is read the first time MCC maps are needed, and again when a joiner
cannot find the host's map (so an item subscribed just now is found). Dedicated
servers also refresh after sv_reload, on a pregame frame; a request during a
game waits until the lobby. Web map-list reads remain cached. The json
files are the item makers' text: one that is too large (256 KB), too deep, not
an object, or that names a path leaving its item, refuses that item or map and
nothing else.
Several Workshop items belong to a collection that their makers published as a
set (a competitive pack, a social pack, a 2v2 set). workshop_collections.c
holds a fixed, curated set of Halo CE collections as data: a name and the ids of
its items. It does not query current Steam collection membership.
game.mcc_collections (HALO_MCC_COLLECTIONS=1) enables these groups by
default. Reopen the map list after changing it. Imported packages can identify
their collection through workshop_id.txt, without Steam. At the
top of the MCC map menus a collection the player has an item of is a folder
([PRO EDITION]), before the package folders; it holds the maps of the
player's items that are in it, by their Workshop titles. An item that is in two
collections is in both folders; an item in none keeps the package folder of its
own, named by its title. A collection with no subscribed item has no folder.
Only the menu changes: levels are still mcc_maps\<item id>\<map name>, so
a host's map and a joiner's messages do not depend on collections. A collection
the table does not know is shown as its items' own folders.
The two MCC categories show package folders first (alphabetically, in brackets),
then loose maps. Open a folder to choose one of its levels; the rows omit the
repeated package suffix, while the selected map's details retain its identity.
Only folders with maps of the selected category appear. A mixed package appears
in both categories, with campaign and multiplayer maps filtered separately.
Back returns from a folder to the package list; at the root it exits as before.
Campaign difficulty selection still follows mission selection. Returning from
that screen restores the MCC folder and selected mission. Each category remembers
its folder/selection for the current session, separately for New Game and hosting.
A rescan restores selections by identity, and returns to the root if a package
has disappeared. _shared, resources and empty/unsupported-only folders are not
selectable packages.
Folder grouping lives in mcc_maps.c. The existing MCC menu callbacks bind its
rows to the shared widgets. MCC Back handlers on the enclosing screens and
lists are needed because screens consume Back before their children; two
MCC-only description widgets show folder and empty-category text. The common description update
hides those widgets when leaving MCC. Xbox/CE lists, map identities, loading,
resource selection, checkpoints and network messages are unchanged.
Open the map-kind chooser and select MCC SINGLEPLAYER for campaign
maps or MCC MULTIPLAYER for multiplayer maps. The cache header's scenario
type determines the category, independently of the filename; both lists
read mcc_maps and its immediate package folders. New Game's campaign maps proceed to difficulty
selection, and multiplayer maps can be explored alone. The network host
map screen routes campaign maps to cooperative setup and multiplayer maps
to gametypes. Split-screen multiplayer skips MCC SINGLEPLAYER, just as
it skips the existing singleplayer categories. These
are menu routes in the implementation; multiplayer interoperability and
complete campaigns require gameplay testing.
Without campaign metadata enabled, each selected MCC campaign map remains an
independent scenario. CAMPAIGN MISSIONS under Settings > Network Setup >
MCC Packages (game.mcc_campaigns) is enabled by default to discover Workshop
campaigns and use their authored mission order. The same screen exposes desktop
Steam discovery and collection folders, also enabled by default. Players can
turn each option off; saved choices and environment overrides are respected.
ModInfo.json must identify Halo1 and GameModContents.HasCampaign = true.
CampaignInfo.json supplies an explicit CampaignMaps list; each referenced
mission JSON supplies ScenarioFile and an optional Title.Neutral.
The order in that list is authoritative, even when filenames sort differently.
The last component of ScenarioFile names the compiled map, following the
public Excession format.
A package contains one campaign, whose mission list can be reordered in
Excession.
The bounded reader supports 1-64 missions, rejects duplicate paths or filenames,
and accepts the default mission kind. Hub/flashback semantics and insertion-point
selection are not implemented; missions start normally at their beginning.
For local packages, keep ModInfo.json and CampaignInfo.json at the package
root and the referenced mission metadata in its original subfolders.
The maps may remain in the Workshop maps folder or sit directly in the root.
The Android importer performs this layout conversion and preserves the Workshop
ID in workshop_id.txt. Metadata never redirects loading to another package,
Xbox or CE. A local override never borrows metadata from its Steam counterpart.
Missing map binaries remain in the declared order: completion stops with a
diagnostic instead of skipping a mission. Unlisted maps remain independently
selectable and do not acquire an inferred next mission.
Solo completion queues the next explicit MCC level with the current difficulty;
the last mission returns to the menu. In co-op only the host chooses the next
mission, using the existing round transition and content-admission messages.
The lobby selects that mission; the final mission returns to the lobby without
wrapping to the first. Clients need matching map/resource content, not identical
metadata or package folder names. No network fields or agreement rules changed.
The minimal main_won_map_private hook is necessary because the established
completion table cannot represent MCC package identities; all selection logic
remains in MCC modules, behind loaded-campaign and setting guards. Xbox and CE
completion paths are preserved.
MCC checkpoints retain the canonical mcc_maps\[package\]<filename> scenario
identity, including when the original tag names an Xbox campaign level.
Continue and Load Game have MCC-specific routes with separate saved-name
storage; they do not turn an MCC checkpoint into a stock campaign level.
The catalog scans mcc_maps, one package directory level and each package's
fixed maps subfolder. It reads each candidate's 2,048-byte header,
and refreshes when a map menu opens. It accepts at most 1,024 entries, with
relative level paths of at most 54 characters before .map, including the
package name and separator; the physical maps subfolder adds no identity
characters. Other deeper nesting, traversal and invalid names are
rejected. Moving an existing loose map into a package changes its saved-game
identity; keep it at its old location to continue an existing checkpoint. A description is optional;
the default identifies the scenario type. Previews use explicit package metadata,
not guessed image sidecars. There is no
dependency on the Custom Edition setting or its resource directories.
The loader opens source maps read-only. A rejected map reports the failing
stage in debug.txt and returns a menu error. Network admission compares all
32 bytes of a SHA-256 fingerprint covering the complete map and each required
external resource file. The MCC tag reader determines those dependencies; the
same validated resource selection is used for conversion and fingerprinting.
File types and lengths frame the hash input, while paths and unused resources
are excluded. Identical bytes in package, root or shared locations match.
The host sends this fingerprint in its existing settings record. Clients first verify the exact installation path, then look for a unique matching same-filename map in their MCC catalog. Ambiguous fallback matches, missing/mismatched resources, or more than 16 same-filename candidates are refused with an explanatory error. The selected local path stays local; readiness replies and game options retain the host's session name. A fresh fingerprint is checked at actual loading too. The host's advertised name still follows the existing network path validation. Map changes and disconnects discard the binding. No client gains host authority, and content matching does not prove that an untrusted client executes honest code.
The issue #51 metadata cache still avoids full resource reads on each lobby
readiness poll. mcc_cache_checksum prepares the host's SHA-256 identity
during map-version calculation, before opening an initially MCC lobby.
Fast setup's early MCC selections wait in mcc_ui_network until the host's
local client has joined its temporary lobby; they then use the normal map
change path. Starting the temporary map is blocked while a selection waits;
legacy selections and session teardown cancel the pending request.
Deferring hashing until the first settings send blocked the host's local client beyond
its five-second join deadline on large packages. mcc_identity_prepare_host
retains the existing host cache while map/resource metadata stays unchanged;
settings sends recheck those stamps and changed files require a fresh hash.
The local admission can reuse that prepared fingerprint only for an identical
canonical path, complete file snapshot and all 32 digest bytes. This avoids
hashing the host's unchanged package again while a remote client waits to join.
Other machines still fingerprint their own installation, and actual loading
always fingerprints the opened content independently. The timeout values,
wire format and fingerprint bytes are unchanged. Large packages still take
time to validate; this does not make synchronous I/O immune to stalls.
The previous 32-bit checksum
remains for checkpoint identity and engine bookkeeping; it is no longer the
MCC network content proof. Existing save identities are unchanged by SHA-256.
The MCC checksum consumers share the port's prefixed zlib CRC implementation;
resource selection/framing, saved checksum bytes and zero-identity handling
remain unchanged. See the checksum reading route.
All peers require the shared OpenCE protocol 42. Xbox and Custom Edition retain
their own map matching/loading behavior; the common wire and simulation agreement
is specified in the network boundary. Network
support uses OpenCE's host-authoritative engine, not official MCC clients.
The shared identity integration uses the settings record's appended digest,
the two host settings senders, client settings admission, and client teardown.
These hooks are necessary because MCC modules alone cannot attach data to the
existing host record or resolve a local path before its generic presence check.
Startup coordination also needs small server map-selection, idle and start
hooks: the server owns when a requested map is applied and when its round can
start. The pending request and its cleanup remain in mcc_ui_network.inl,
using the existing MCC server-disposal hook. Xbox/CE requests proceed through
their existing map-selection code immediately.
All hashing, package selection and binding lifetime policy lives in MCC modules;
Xbox/CE settings use a zero digest trailer and keep their original map checks. The
protocol recorder includes the full MCC settings record and its size/offset
bounds; all three map families use the shared OpenCE version 43 contract.
MCC's halo1/maps/bitmaps.map stores individual texture entries. Its
halo1/maps/custom_edition resources store grouped __pixels and
__permutations entries. Custom packages may use either layout.
The MCC reader supports both. Grouped reads require a unique exact tag-group name
and the original requested offset entirely within its validated payload. Grouped
slices are never relocated by guesswork. Bounds and name checks still apply.
MCC maps use a generated, stock-style pause menu for campaign, cooperative and multiplayer games. The full, half and quarter viewport layouts follow the local player arrangement. They use separate MCC-owned widgets, strings, panels and selection highlights; the default pause route does not open the map's embedded pause or Settings widgets. Loaded font tags are referenced without changing their contents.
| Context | Available actions |
|---|---|
| Local campaign | Resume Game, Settings, Revert to Saved, Restart Level, Save and Quit. |
| Cooperative host and client | The campaign actions plus Friendly Fire On/Off. Clients cannot perform host-only checkpoint/restart actions. |
| Local multiplayer and multiplayer client | Resume Game, Settings and Leave Game. |
| Multiplayer host | Resume Game, Settings, End Game and Leave Game. |
The full-screen menus match the Xbox layouts and content, including the port's Settings and co-op Friendly Fire additions. The extra MCC Choose Team and multiplayer Restart Game entries have been removed for content parity. Authored widgets still use the existing MCC action adapter. Split-screen players use Settings from the main menu, since the editor needs a full viewport.
Revert and Restart use the Xbox ATTENTION dialog: B/Back cancels and A/Start accepts. Save and Quit uses the three-second SAVING screen and preserves the last valid checkpoint; it does not create a new checkpoint. The wording, including the inherited Xbox-console saving message, follows the Xbox reference. Multiplayer Leave and host End Game act directly, as on Xbox. Only local campaign menus pause simulation; network games continue.
Footers use separate B=CANCEL and A=SELECT widgets, with B=CANCEL and A=OK on confirmations. Their bitmap placeholders reference OpenCE's embedded small menu-button redraws, independently of the map's gameplay glyphs. Panel and alert bitmap descriptors borrow the native menu loader's redraw textures read-only, with MCC-owned groups and frame selections. Unload drops these descriptors before the native menu loader releases the textures. Selection highlights are drawn independently with antialiased rounded edges.
Friendly Fire changes only the existing network.coop_own_friendly_fire
preference, through the same configuration service as Xbox. The generated
button reloads its label after a successful change. This introduces no new
network message or authority: checkpoint/restart and End Game still require
the host; clients cannot turn the preference into control of other players.
The menu callbacks close only their initiating controller's tree and history.
All full-screen Settings entries open OpenCE's existing in-game audio, video and controls editor, with upstream's option filtering and profile saving.
The MCC Settings route uses the initiating controller's profile and widget history. It does not replace another active profile editor. Its ownership ends on native Save/Cancel, menu closure, replacement editing or map unload, so a later native editor cannot be closed by stale MCC state.
Campaign layouts display the scenario's current mission objectives through the native objective-text callback. Owned objective and confirmation text boxes wrap their instance copies using the current font's metrics and clip to their bounds. The map's objective data, custom HUD and embedded widgets remain present. Scripts that explicitly open embedded widgets can still use the MCC callback adapter described below. The new pause labels and confirmation text are currently English; localization of these generated strings is not implemented.
The MCC-owned policy in mcc_share_rules.c applies to local and Workshop
packages. The host's network.map_share setting enables eligible packages
automatically after their gameplay content has been validated. Loose maps,
_shared, unsafe names and invalid origin states are refused. A Workshop ID
is advisory; it neither grants redistribution permission nor proves which bytes
are present. An existing mcc_share.txt can supply attribution, but no approval
list is required. Required JSON is separately identified and validated.
The planner uses the loader's validated resource selection. Self-contained maps
do not transfer unrelated resources; used package dependencies follow their
actual resolved paths, including Workshop halo1/maps. A used root/shared
resource is never transferred: the joiner must supply its matching local copy.
Package copies identified as base resources are excluded too. An invalid
package override cannot be silently skipped in favor of another resource.
When joining a host, OpenCE checks the installed base-resource candidates against the host's full SHA-256 content fingerprint. An older file in the MCC root does not hide a matching copy in either shared folder. Package-owned resources keep precedence; a broken package override is not silently replaced. The loader uses the exact resource selection that passed validation and checks the loaded content again before joining. Missing matches require the player to install the matching resources locally; the host never supplies base resources.
Host sharing remembers whether a package resource duplicates a local base file. Repeated requests reuse that classification only while the map and every resource candidate retain their file stamps. A changed candidate forces a fresh comparison.
The host delivers MCC packages itself, with the joiner's consent: eligible Workshop packages, recognized JSON/PNG assets and separate managed snapshots. The messages are request 103 and response 104; see NETCODE.md. Custom Edition sharing and its messages remain independent.
Enable host network.map_share and joiner network.map_download (both default
on). The same host setting covers CE maps and MCC packages. A missing/differing package
prompts before any chunk download or stage creation. When either permission
is off, only manual installation or a valid Workshop page is offered as a
content-acquisition action, plus cancellation. Matching installed content
needs no download; content is not assumed newer/older solely from a mismatch.
The current mission's map and selected resources travel with required package, campaign and mission JSON, supported referenced PNGs and attribution text. Local map-only folders are valid; no JSON, artwork or Steam identifier is invented as a prerequisite. Campaign metadata is delivered upfront and later mission binaries are obtained as needed. Received metadata cannot introduce arbitrary paths or remote downloads; invalid optional artwork is discarded, while invalid required metadata blocks installation.
On-demand campaign progression uses the connected host's exact identity for each next mission. A downloaded mission remains individually selectable, but separate downloaded snapshots do not assemble an offline or rehosted campaign. Campaign JSON specifies names/order, not every mission's binary digest; even identical JSON and Workshop provenance cannot prove that another snapshot is the intended revision. If the current snapshot lacks its next mission, the existing progression handler refuses that transition. Install the complete campaign from Workshop or a manual package for offline/rehosted progression, or rejoin the original host for its next mission.
The receiver verifies files, metadata references and both advertised identities
inside its owned mcc_staging/dl_<digest> directory. Native publication moves
the whole directory without replacement into mcc_maps/dl_<digest>, preserving
existing manual and Steam copies. It rechecks that installed snapshot before
joining. These filesystem checks protect against remote paths; they are not a
sandbox against a malicious process with the same local filesystem authority.
Managed snapshots are listed, stored and removed from the menus; removing one keeps the original package. See the implementation walkthrough.
The contribution targets OpenCE. source/ contains the reconstructed
Xbox game systems, including scenario/tag access, cache I/O, the script
interpreter, rendering, audio, objects, game variants and UI. The native
platform layers under port/linux/, port/windows/ and port/android/
provide the host services used by those systems. The desktop renderer
implements the game's Xbox interfaces using the existing native graphics
backend. Menu XML and generated settings define the native map chooser.
The tools/ tests and native harnesses exercise both portable utilities and
selected game subsystems.
Existing Custom Edition support has its own catalog, cache reader, conversion, resource and behavior modules. Those modules and their state are not an MCC implementation dependency. The independent components are:
| Component | Responsibility |
|---|---|
port/linux/game/mcc_package.c |
Validated package paths and explicit resource overrides. |
port/linux/game/mcc_maps.c |
Catalog, display identities, names and descriptions. |
port/linux/game/mcc_cache_format.c |
Portable little-endian version-13 reader and file-range audit. |
port/linux/game/mcc_cache.c |
MCC path admission, read-only file lifetime, conversion and streaming dispatch. |
port/linux/game/mcc_identity.c, mcc_sha256.c and mcc_precache.c |
SHA-256 session content checks, local package resolution and metadata-based readiness caching. |
port/linux/game/mcc_main.c |
MCC load-failure recovery through the native main-menu lifecycle. |
port/linux/game/mcc_ui.c and mcc_ui_network.inl |
MCC in-map widget actions, settings routing, checkpoint/quit behavior and synchronized network restarts. |
port/linux/game/mcc_pause.c and mcc_pause_runtime.c |
Generated stock-style pause layouts, objective display, independent UI art and atomic publication/lifetime of the appended tags. |
port/linux/game/mcc_ui_teams.c |
Authenticated team-only requests during MCC multiplayer rounds, with host balance checks and normal respawn replication. |
port/linux/src/mcc_memory.c |
Separate 64 MiB linked tag window; never replaces an existing allocation. |
port/linux/game/mcc_geometry.c |
New model descriptors, model vertex/index conversion, external BSP vertex streams and node palettes. |
port/linux/game/mcc_audio.c |
MCC sound decoding, resampling and Xbox ADPCM encoding into an MCC virtual stream. |
port/linux/game/mcc_resources.c |
MCC-only resource selection, dependency fingerprints, indexed reads and file lifetime. |
port/linux/game/mcc_vorbis.c |
Private namespaced Vorbis decoder, bounded Ogg validation and empty residue vector compatibility. |
port/linux/game/mcc_bitmaps.c |
MCC pixel layout, BC7 decoding and shader/HUD channel normalization into an MCC virtual stream. |
port/linux/game/mcc_texture_cache.c and port/linux/src/mcc_texture_bridge.c |
Direct bindings of checked MCC pixel allocations and lazy GPU textures, independent of the Xbox/CE staging cache. |
port/linux/game/mcc_tags.c |
MCC metadata, shader-type, HUD placement and widget normalization. |
port/linux/game/mcc_hud.c |
MCC bitmap/placement scaling, including nested weapon and grenade HUD items. |
port/linux/game/mcc_hud_draw.c |
MCC canvas, glyph geometry and text advances; neutral dispatch for Xbox/CE. |
port/linux/game/mcc_terminal.c |
MCC terminal-only font scaling; preserves the map's HUD fonts and all legacy rendering. |
port/linux/game/mcc_scripts.c |
Name-based MCC function/global linking and supported MCC native functions. |
port/linux/game/mcc_campaign.c |
Local-player/authority queries, gravity, campaign markers and scoped global permissions. |
port/linux/game/mcc_syntax.c |
MCC's 32,767-slot syntax validation and traversal workspace. |
port/linux/game/mcc_script_parameters.c, mcc_script_runtime.inl, mcc_script_threads.inl |
MCC parameter metadata/scopes and bounded, checkpointed interpreter stacks. |
port/linux/game/mcc_objects.c |
MCC multiplayer vehicle placement masks. |
port/linux/game/mcc_grenades.c |
MCC slots 2/3, salted unit inventories, pickup/throw/drop behavior and HUD. |
port/linux/game/mcc_player.c |
MCC grenade selection/action checks and starting-profile counts. |
port/linux/game/mcc_network.c |
MCC host inventory and campaign-state messages over the existing distributed transport. |
port/linux/game/mcc_checkpoint.c |
MCC inventory/campaign snapshot inside proven-unused CPU save memory. |
port/linux/game/mcc_tag_validate.c |
Independent range/ownership state while applying stock tag schemas and their validators. |
Shared engine entry points have additive MCC dispatch for an MCC-namespaced level or active MCC state. They route cache lifetime, raw resources, BSPs, script extensions, validation callbacks, menu text and model palettes to the new modules. For other levels those MCC checks do not select a loader. The new code does not call the Custom Edition parser, converter, allocator, script adapter, bitmap converter, sound encoder or behavior table. MCC conversion writes only MCC-owned allocations, and unload releases them.
The pause builder appends its definitions and art to a copy of the live
tag index only after construction succeeds. It preserves the existing tag
records and restores the original index on unload. Its action IDs use the
separate 0x7000 range and require exact ownership of a generated widget;
an embedded map widget cannot acquire those permissions by copying an ID.
Allocation or graphics-resource failure releases the partial construction
without publishing it. Xbox and Custom Edition pause selection remains on
the existing route.
Maps with two through four grenade definitions are supported. The original unit datum and player-action layouts are retained; the extra two counts live in a separately owned table keyed by full salted unit handles. Selection remains in the native unit fields. MCC profile, input, HUD, pickup, throwing and inventory-network routes handle these slots.
MCC saves put the additional counts and campaign state into a 66,392-byte slot at the CPU
arena's end only if the allocator's current high-water mark leaves that
entire slot unused. No game_state_malloc call, pool capacity, native
allocation checksum or save-image size changes. Native checkpoint, core
and persistent writers already serialize the complete CPU/GPU arena;
the persistent image checksum therefore includes this snapshot. An MCC
footer adds version, canonical map identity, cache checksum and payload
CRC32. Before accepting the image, the adapter checks the payload and
remaps incoming object-header pointers to verify every salted unit record.
Unload restores the original unused bytes, including nonzero contents.
The version-2 payload includes gravity, navigation markers, dialogue gain
and the campaign's infinite-ammunition flag. Version-1 inventory snapshots
remain readable, with the new campaign state initialized to its baseline.
The footer remains at its original address. Images are validated before
restoring either state.
Campaign snapshots use the existing OpenCE host/client transport, authority checks and stale-tick filtering. They are sent only in MCC games; the native inventory and co-op message layouts are unchanged. Protocol version 27 is required on every peer because this adds message type 84. Version 26 was already used by the separately prepared OpenCE contribution branch. This is an additional message in OpenCE's protocol, not an MCC networking stack or compatibility with the retail MCC client. Client cheat restrictions remain in force; only the host decides ammunition consumption.
This is an independently written implementation of documented wire formats,
informed by reading the existing engine's public interfaces and schemas.
No Custom Edition implementation was copied or renamed. Generic engine
operations, including vertex compression and GPU buffer construction, are
shared. MCC compiles a private namespaced instance of the unchanged generic
stb_vorbis library to decode Ogg; Xbox/CE retain their existing instance. The
MIT-licensed port/third_party/bcdec dependency decodes BC7 and DXT blocks;
its accompanying license and provenance are retained. This statement does
not claim the legal two-team meaning of formal clean-room reverse
engineering.
The reader admits little-endian head/foot caches with version 13 and
singleplayer or multiplayer scenario type. Tag memory uses the base
inferred from the tag-array pointer minus the 40-byte MCC tag header.
Each index entry is 32 bytes. Linked pointers are checked against the
loaded data before access. File and multiplication ranges use subtraction
or wider arithmetic to avoid wrapping.
Models use the MCC mod2 part layout and uncompressed 68-byte vertices.
The adapter creates new 104-byte Xbox part descriptors, compresses vertices
to 32 bytes and uploads the index strips. Local node indices are mapped to
global nodes when possible; models requiring more engine palette slots
use an MCC-owned palette per part. No CE palette storage is consulted.
Version-13 BSP vertex data is external to the BSP tag allocation but can be embedded in the same map file. The adapter follows the BSP header's vertex byte count and file offset, reads the material's 56-byte environment and 20-byte lightmap streams, and compresses them into adjacent 32-byte and 8-byte streams. The converted streams have a separate tracked lifetime; BSP changes release only the previous BSP's buffers.
Bitmap conversion supports the common Halo pixel formats, including P8,
DXT1/3/5 and MCC's BC7 format 18. BC7 is decoded to ARGB8888 for the existing
renderer. Pixel rows, Morton ordering and cube/mip layout are packed by
the independent MCC adapter. The MCC environment bitmap flag is metadata, so it is cleared
when constructing the Xbox descriptor. Compressed and palette flags are
derived from the resulting format. Model flag 0x40 and HUD meter flag
0x20 identify resources already in Xbox channel order. Those channels
are preserved; references with the flags clear receive Gearbox-to-Xbox
channel conversion. A bitmap used by consumers
that require different channel layouts gets separate MCC-owned tag and
pixel copies, with the relevant consumer's reference redirected. The tag
index can grow into a separate checked allocation for those copies.
Unflagged (Gearbox-order) MCC meters also omit the Xbox RGB opacity tint.
Their converted clone stores fill order in red/blue and authored shape coverage
in green/alpha. The MCC texture bridge selects the renderer's existing filtered
coverage and discrete-threshold interfaces for that clone only. This preserves
the scene beneath partially covered edge pixels, filters curved fills like
their adjacent outlines, and avoids interpolating ammunition segment IDs.
The original bitmap, explicitly Xbox-order MCC meters, and Xbox/CE texture
paths keep their existing sampling. Descent provided concrete examples:
decent\ui\hud\odst_eva uses opacity 1 for its unflagged shield meter;
its shield and health shapes occupy different curves within 512-by-64 images.
Those authored shapes and the space between them are retained, not enlarged
to fill their surrounding outline.
Unflagged MCC HUD placements use a 960p canvas, converted to native 480p coordinates in MCC-owned tags. Legacy high-resolution placements (flag 4) already carry 480p anchor offsets and retain them. Bitmap size conversion is independent of that offset flag; the flag is consumed before native drawing. Bitmap half-scale flags are a separate factor, so high resolution images retain their original texels. Anchors, number advances, waypoint/damage margins and direct icon geometry are normalized; the motion-sensor radius and font-relative icon offsets/advances already use native units and are retained. Five native HUD/UI files contain additive dispatch only: every pre-existing statement is retained. Xbox/CE dispatch is neutral before any bitmap lookup or draw. The pause A/B glyphs and pickup icons use their own bitmap flags, with matching cursor advances so text remains beside the correctly sized icons. Pause glyphs align to the active UI font's capitals instead of inheriting a map's custom HUD icon baseline.
Gameplay A/B/X/Y prompts use OpenCE's embedded hand-drawn button artwork, with visible bounds centered on the active font's capitals. Controller entries are identified by their HUD-global entry, not their sprite sequence, so custom weapon/pickup pictures remain map-authored. MCC owns and releases these bitmap placeholders on unload; the pause-menu path is unchanged.
Weapon HUD static elements, meters, numbers and overlays also honor MCC's per-element child anchors (0 inherits, 1..9 select an absolute anchor). The field occupies the native header's padding at byte 6, as documented by Invader's weapon HUD format. Each draw resolves a temporary placement without changing the parent tag. This places A50_Revisited's visor at the screen edges; invalid child anchors retain the parent placement. Xbox/CE returns the original parent untouched.
HUD normalization first plans ownership from pristine loaded bytes in
mcc_hud_ownership.inl. Same-group aliases of a root are converted once.
Shared mutable blocks receive separate consumer storage before any placement
or pointer is written. Pointer-free crosshair and overlay items are always
snapshotted: an MCC cache can intern them within storage used outside the HUD
tree. This prevents one consumer's scaling or frame marker from changing the
authored input seen by another. It also makes supported scalar interning
independent of the later validator's traversal order. This is a correction
within the MCC compatibility engine, not a map-specific exception.
Pointer-bearing aliases retain their largest original extent so the later validator still rejects conflicting owners, cross-schema roots and partial overlaps. Planning is bounded by the validator's four-million-visit budget. All copies precede pointer publication; allocation failure refuses the load. Planning records are freed on every exit, and copied blocks belong to the runtime tag arena, released by normal unload or failed-load cleanup. Neither original map files nor Xbox/CE conversion paths are changed.
Stock corner HUDs use the native safe frame instead of the wider MCC frame.
mcc_hud_layout.inl recognizes component layouts before conversion from their
anchors, placements, number layout and overlay counts. Unit HUD recognition
also includes bitmap dimensions/registration points and sprite geometry.
Bitmap names remain bounded and validated but do not select the frame.
Weapon and grenade counter panels deliberately exclude artwork identity and
sprite choices: a custom replacement bitmap does not relocate a stock counter.
Grenade icons retain their own authored size and offset within the counter's
frame. Bitmap and overlay references are still bounds-checked. Handles,
padding, colors and independently centered crosshairs do not select the frame.
The fingerprints were measured from locally installed MCC version-13 a10,
b30, b40, d40, bloodgulch, deathisland and carousel caches. No map assets are
embedded. Unknown layouts retain the authored MCC frame; this is deliberately
conservative and is not a security or content-identity check.
These structural profiles remain a compatibility exception: the supported anchor and scale fields do not establish whether an author intended the native or wider safe margin. Removing the profiles requires evidence of a reliable format or usage rule that preserves both stock and custom layouts, with near-miss coverage. The Stage 5 inventory found the same classification for all 487 component HUDs in ten installed Workshop maps after removing bitmap-name dependence; changing only names also preserved classification. This bounded result does not establish that the profiles recognize every stock derivative. One load diagnostic reports native/authored frame counts and ownership copies; no diagnostic runs per draw.
Recognition is read-only and runs once on each distinct pristine root.
Conversion then writes the chosen marker into runtime-owned MCC placement
padding, replacing map-supplied values. A weapon and its inherited parent HUDs share one
frame: mcc_hud_weapon_frame_begin follows the outermost populated parent
layout in the bounded chain, ignoring empty/crosshair-only parents. A chain
with distinct authored anchors retains the MCC frame. This lets a custom ammo
meter inherit its stock parent counter's margin without moving shared tags or
classifying the whole map as stock. mcc_hud_weapon_frame_end clears the choice
after that draw. The three-line additive hook in hud_weapon.c is needed
because a parent tag can be shared by both custom and stock weapon HUDs;
conversion alone cannot know which child is currently drawing it. No shared
parent tag is mutated during rendering. Xbox/CE dispatch remains neutral.
Stock top-left messages (zero horizontal offset, 60 native pixels down) use the same native safe margin. Other message offsets and anchors retain their authored MCC placement. With High-Res HUD enabled, MCC controller glyphs use the native HUD's dimensions, capital-center alignment and text advance, with the selected button style and split-screen scaling. Low-resolution glyphs retain their existing geometry. Mercury Falling's pistol, ability counters and vehicle prompts exposed these separate cases; the rules do not depend on map or weapon names. Descent's custom layouts remain separate.
The asset-free ownership and normalization cases in
tools/test_mcc_hud_normalization.py exercise the whole converter, including
shared roots/blocks, order independence, separate frames and allocation failure.
tools/test_mcc_tag_validation.py combines conversion with the actual validator
to check supported scalar interning and malformed pointer-bearing overlaps.
The layout, channel and texture-ownership tests are in
tools/test_mcc_hud_layout.py, tools/test_mcc_shader_channels.py and
tools/test_mcc_texture_bridge.py. tools/test_mcc_hud_meter_render.py renders
synthetic converted meters through the production GPU shader, checking full,
empty and partial fill with fractional coverage and placement. Visual checks
must also cover real stock/custom MCC HUDs at native resolution; synthetic
tests alone cannot establish that every authored layout matches MCC.
MCC Chicago shaders that explicitly request Custom Edition blending (extra
flag 0x4) use black-neutral modulation for double multiply. Frogfoot's
waterb layer sets this flag; ordinary double multiply turns its dark pixels
into black water. The MCC adapter uses destination * (1 + source) and fades
the source toward black, preserving the background at zero contribution.
This is an independently implemented interpretation of the black-transparent
behaviour documented in the Chicago format reference,
validated against Frogfoot's authored layer and local visual comparisons;
exact pixel parity with native MCC has not been established. Other blend
modes and unflagged shaders retain their original behaviour. The adapter
runs after native Chicago state setup because tag conversion alone cannot
express this blend and its matching fade. Each subsequent shader installs
its normal blend state; the adapter retains no per-map state.
MCC player_add_equipment calls use the MCC script registry and
mcc_player_add_equipment. A reset deletes the held weapon through the
normal object-deletion service before applying the native starting profile.
The inherited Xbox inventory clear keeps the held weapon;
Meincrap 2's campaign selector readies a dummy weapon, so keeping it caused
repeated profile changes with a blank viewmodel and a stale hotbar selection.
The local version-13 meincrap2.map contains weaps and set_weap_and_hp:
the former detects the dummy or flashlight state, and the latter applies a
reset profile twice across a one-tick sleep, restoring vitality each time.
Each profile supplies a real weapon and another dummy. This inspected script
flow, and a reproduced ordinary switch-button failure, motivate the MCC-only
reset semantics; the Xbox/CE clear routine is unchanged.
The adapter validates the player unit and profile before deleting anything, leaves add-only calls intact, and runs only on the authoritative machine. It targets exactly the unit supplied by the script; MCC's per-player selectors must not inherit the legacy co-op follower expansion. It retains no sidecar state and uses existing object/inventory replication and deletion cleanup. MCC admission version 61 separates the changed equipment behavior from older MCC peers; the OpenCE wire format and Xbox/CE admission version stay unchanged.
MCC equipment scripts may delete the currently displayed weapon before
creating its replacement. A deletion notification clears matching local
first-person references while the old object still exists; unrelated weapons
and Xbox/CE maps keep the original path. This notification must run at the
engine's weapon-deletion boundary, which the script adapter alone cannot
cover (including replicated deletions). MCC also admits positive authored
item scales from 0.001 up to the native 0.5 lower bound, as used by
MeinCrap's block weapons. The item update already applies these scales;
only its validation gains the guarded MCC allowance. The native upper limit,
zero/invalid rejection and all Xbox/CE limits remain unchanged.
MCC textures bind their immutable converted allocations directly through an MCC-owned hardware-header registry. Exact registered header identity grants access to the pixels; a copied descriptor or arbitrary physical-address word does not. GPU textures upload lazily and remain owned until MCC unload, which unbinds and deletes them before freeing their source pixels. This avoids another pixel copy and allocation in the Xbox/CE texture staging cache, whose capacity and policy remain unchanged. BC7 decoding retains the full decoded texels; there is no additional lossy recompression or resolution reduction. Host memory and GPU texture capacity still bound the maps the machine can render. The same owned pixels remain available to CPU object-lighting samples. Two-dimensional DXT resources preserve their complete 2-by-2 and 1-by-1 source mip blocks for those samples, while the GPU descriptor retains its native mip limit. Unload clears only CPU base pointers that still name the MCC-owned allocation.
The audio adapter accepts embedded or externally indexed PCM16, Xbox ADPCM and Ogg Vorbis permutations. It uses independent bounds checks and codec state. Mono output uses the game's 22,050 Hz format; stereo output follows the admitted 22,050/44,100 Hz tag rate. Necessary conversions produce an MCC-only ADPCM stream. Unsupported or damaged audio rejects the map instead of silently removing sound. External ADPCM that already matches the native sample rate is validated and retained byte-for-byte. The independent resource reader checks the 16-byte resource header, bounded names/index tables, resource type and payload ranges. Sound names identify the tag, pitch range and permutation; bitmap names identify the tag and image. Indexed whole-tag replacements are still unsupported.
Compiled script function and engine-global indices are linked by the
names retained in the script strings. The adapter provides
objects_distance_to_object and mcc_mission_segment, and maps
player_effect_set_max_vibrate to the engine's rumble operation.
Other unresolved names reject the map. mcc_mission_segment evaluates its
string argument normally, records a bounded local diagnostic event and
returns true for a supplied string. This acknowledges the event locally;
it does not implement the MCC telemetry service. The boolean result retains
the conditional sleep calls used in shipped and Ruby campaign scripts.
It does not call core_save_name: that Xbox function writes a raw debug
save, and remains unchanged and unavailable to map scripts.
An MCC campaign mission's scripts may call map_name, which H1A custom
campaigns use to end a mission and load the next: (map_name "x05_captured")
names a mission of the same package (mcc_maps\<package>\x05_captured),
whose script ends the level as game_won does, with that mission next, with
or without a campaign manifest (mcc_main_campaign_won). Alone it loads; a
network co-op host takes every machine there; a dedicated server plays its
rotation's next entry, as after any won level. A name that is no campaign
mission of the package does nothing (logged), and no map's script may load
any other map. Before, the refused call disabled its whole script: the
missions' endings (their last cutscene and level change) never ran.
Global initializers may not change maps, even through a static script; the
call is logged and ignored until made by a script thread or the console.
mcc_main_script_level_resolve owns the same-package destination lookup;
the shared main_script_level_resolve delegates only MCC level names to it.
MCC scenarios may call the zero-argument, void ai_deselect operation through
the MCC registry in mcc_scripts.c.
Its evaluator calls the existing ai_scripting_deselect service in
ai_script.c. When AI is initialized for the map,
that service clears the selected encounter and actor through the native debug
selection routines, retaining their evaluation-record and idle-look cleanup.
The adapter adds no persistent state or checkpoint fields. Registry lookup
requires loaded MCC tags, so unloading removes access through the existing
lifecycle. Xbox/CE keep their original map-function allowlist; ai_select
and other debug operations receive no new permission. Client console authority
checks also remain unchanged.
The installed Quarantine Workshop map has one valid (ai_deselect) call in
its continuous life_lost_0 script. The previous native map-policy refusal
disabled that entire script, including its cooperative game-over sequence.
The fix admits the operation for every accepted MCC map, without selecting a
map name or replacing it with a no-op. Enabling previously refused authored
gameplay originally raised MCC to protocol 65, while that change left message
layouts and Xbox/CE's then-current OpenCE 41 contract unchanged. Current
agreements are listed in NETCODE.md. Source-derived tests exercise native selection
clearing, inactive-AI behavior, native map refusal and client console policy;
the MCC script harness covers linking, malformed arguments and unload guards.
These checks establish the operation and its boundaries, not a complete
Quarantine playthrough.
Additional MCC campaign operations include local_players,
game_is_authoritative, objects_distance_to_position, sleep_forever
(current or named script), gravity setting/reset and breadcrumb navigation
at positions, flags or objects. Local players excludes remote and dead
units. Sleep uses the existing interpreter stack and native wake semantics.
Navigation has eight independently owned team markers and uses the native
HUD drawing services; the host replicates the complete marker state and
gravity periodically, including after changes and late joins.
The recognized debug_ice_cream_flavor_status_* globals for IWHBYD,
Grunt Birthday Party and Bandanna report false. This does not implement
skull gameplay. A literal assignment of false is accepted because the
skull is already disabled; attempts to enable one or assign a computed
value are refused. MCC maps may
set sound_gain_under_dialog and cheat_infinite_ammo; the adapter captures
their previous values and restores them on unload. The native global table
and Xbox/CE write permissions remain unchanged.
Compiled MCC static/stub scripts support up to 16 typed parameters.
Signatures, scoped local references and call arguments are checked before
loading. The MCC interpreter extension keeps arguments, mutable local
values and the evaluation cursor in the existing thread stack; object-list
references survive sleeps and release on return or thread termination.
Nested and recursive calls retain separate scopes. After an MCC if selects
a branch of the same result type, its forwarding frame can be released before
evaluating that branch. This prevents MeinCrap 2's nested equipment selectors
from exhausting the stack, while retaining script parameter scopes and all
live state in the checkpointed buffer. Branches requiring a cast use the native
evaluation path. MCC uses 4,096-byte bounded stacks in its own 256-thread array;
Xbox/Custom Edition retain their existing 512-byte stacks and thread layouts.
mcc_script_threads.inl selects this array only for accepted MCC maps. Halo
Kart's main exhausted 512 bytes both while selecting NPC steering commands
and while awarding an item, stopping both features. The larger bound supports
these nested calls without rewriting the map's scripts or removing overflow
checks. It is a compatibility capacity, not a claim about MCC's own limit.
The array occupies approximately 1 MiB below the existing MCC checkpoint slots, only after the CPU allocator's high-water mark proves the region unused. The native allocation records and checksum remain unchanged. The small arena bounds accessor and interpreter hooks are necessary because those private engine state and stack bounds have no existing external interface. All storage ownership, validation and migration live in MCC modules. Unload, failed load and later Xbox/CE loads restore the original array and unused bytes.
Complete saves, including the host's co-op revert image, include the array. Before accepting it, the MCC checkpoint path checks its version, checksum, array metadata, thread bounds, frame chain and result destinations. Supported old checkpoints with native inline stacks are checked and migrated with their intra-thread pointers relocated. MCC protocol 57 requires matching script-stack capacity on peers; the verified OpenCE protocol is unchanged. Script initialization can run while loading on either peer, but only the host runs the race scripts and AI during co-op. Existing object, actor and scenery-animation replication carries their effects; thread stacks are not a new network message. This adds no client command or permission to execute scripts on the host. Malformed or insufficient storage is refused rather than truncated.
Halo Kart C34 also exposed passenger AI entering the native danger-avoidance
action, whose firing-position selector asserts that the actor is not a
passenger. mcc_seat_blocks_avoidance prevents that action for MCC passengers
and completes it if scripted seating happens after entry. Two additive hooks
in action_avoid.c are needed at those action boundaries; they leave the
existing Xbox/CE path and movable MCC actors unchanged. The diagnostic run
identified action 13 (avoid), evaluation mode 6 (avoid), and driver type 0
(not a driver). This guard does not suppress the selector's assertion or
rewrite the race's steering commands.
Dynamic console calls with
parameters are not supported by this extension; the cached map's calls
are the supported path. MCC syntax now retains its full 32,767-slot arena,
including unused slots for dynamic console expressions. This is the Halo 1
MCC format's signed 16-bit capacity, not 65,535. MCC's independent validator
checks the complete node span, occupied count, salted references and cycles
before the interpreter follows links. Its traversal and parameter workspaces
cover the full arena. Three additive dispatches in hs.c select MCC's
validation/allocation-admission path; Xbox and Custom Edition keep their
original 19,001-slot constants, validation storage and statements.
Syntax remains in MCC-owned tag memory, with unchanged datum handles and
thread/checkpoint layouts. No shared data-array structure or allocator changes.
The MCC tag walker also retains the full syntax byte span during its later
schema pass; the shared Xbox/CE schema still specifies 19,001 slots.
Ruby's Rebalanced was audited across all ten campaign maps: each reserves
32,767 slots. a10 has a high-water count of 19,723, including 18,480 occupied
nodes; the other nine high-water counts are below 19,001. Its existing holes
are retained rather than compacting or renumbering the graph. Across these
maps, the only unsupported native name was mcc_mission_segment (225 calls,
42 in boolean contexts and 183 with a discarded return value).
Native Ruby loading exposed two additional MCC bitmap layouts. RGB565
lightmaps with flags 0x1281 are normalized only when their owning group is
a lightmap, they have no mipmaps, and the pixel range is complete and tightly
packed. Bit 12's broader meaning is not inferred. The existing descriptor
verifier still checks the normalized result. Four maps also contain a Wraith
HUD DXT1 texture whose tiny mip tail is sized using unrounded pixel counts.
For that exact full-chain size pattern, the converter retains every complete
mip level and logs the omitted tail; it never reads beyond the declared range.
Arbitrary truncation, missing base images and other unknown flags still fail.
Ruby's sound\\music\\spooky1\\in (including b30 tag #3583) uses an
empty residue vector codebook. The generic decoder aborted the rest of the
residue after encountering it, producing an error and incorrect PCM. MCC's
private decoder normalizes only empty additive residue vector references
before the first overlap packet, matching Xiph's zero-contribution behavior.
Empty scalar floor/classification books are not covered by that rule.
Ogg checksums, page continuity, EOS, sample count and remaining decoder errors
are still checked. Decoder buffers return to their own allocator, independently
of the game's debug allocator and the later ADPCM format conversion.
An independent PCM comparison across all ten Ruby maps covered 50,186 Vorbis references and 8,325 distinct streams: all decoded successfully and every sample differed from libsndfile/libvorbis by at most one signed-16-bit unit. These codec checks do not establish a complete campaign playthrough.
Solar Flare and Spasm Playground also use valid final Vorbis granule trims across long/short window transitions. MCC decoding retains the requested PCM frames while validating the remaining packets and a bounded overlap tail. Page checksums, sequence, monotonic granules and decoder errors are still checked. A comparison of 247 permutations from the two reported sound tags matched libsndfile/libvorbis within one signed-16-bit unit.
Combat Revolved's material-less model part retains the native renderer's skip behavior. Its 8192-pixel credits strip uses the MCC texture route; the legacy texture cache's size policy is unchanged. Each bitmap tag has its own virtual stream with exact tag-handle checks, allowing the total decoded texture storage to exceed the former single 512 MiB offset range.
- Modern uncompressed version-13 maps are the target. Earlier Anniversary chunk-compressed caches, Halo 2 or later MCC maps and external indexed tags are not supported. Indexed MCC bitmap/sound payload resources are supported when matching files are installed as described above.
- The portable inspector accepts files up to
INT32_MAX; runtime raw files must be smaller than0x50000000bytes because higher offsets identify MCC virtual resources. Runtime tag windows must be free, 64 KiB-aligned, 64 MiB allocations based between0x42000000and0x70000000inclusive. The observed MCC base is0x50000000. Windows delay-loadsSDL3.dlland reserves this address range at constructor priority 101, before CE's settings read (priority 102) first calls SDL. SDL retains ASLR; it is not patched to use a fixed address. Windows retains the reservation between maps. Pages are committed only during an MCC load and decommitted on unload; other accepted linked bases can replace only our inactive reservation. An occupied range is never overwritten. Allocation refusals report the address, size and OS error indebug.txt. Early reservation failures are retained untilwindows_startupopens the port log, then reported to stderr (normallyhalo.logfor release builds). The map loader still retries the reservation and refuses occupied memory. MCC network load failures schedule session teardown and a menu reload before the next frame's input update, rather than entering the fatal error screen. A player reported that disabling XFire and restarting the game resolved this allocation refusal. This supports interference from third-party software, but the specific allocation conflict has not been captured. Early reservation is not a guarantee of compatibility with XFire; disabling it and restarting remains the confirmed workaround for that report. Separately, issue 87's follow-up records two launches with the unmodified SDL DLL inside the MCC window and a successful launch with SDL's ASLR disabled locally. Those post-startup snapshots do not establish which module first occupied the range. They do demonstrate why a normal load-time SDL import can defeat any constructor. Delay loading removes that SDL race; other eager or injected DLLs can still prevent reservation and must not be overwritten. - There are at most 65,535 tags and 32 BSP references. Runtime conversion descriptors must fit below the lowest BSP in the tag window. Geometry currently admits at most 64 nodes per model, 22 palette nodes per part, 256 geometries per model and 128 parts per geometry. Each part's vertex and triangle counts must be nonzero and at most 65,535.
- Non-volume bitmap dimensions are limited to 8,192 by 8,192 with depth one; volumes are limited to 512 by 512 by 256. There are at most 13 mip levels after the base level. Individual raw/decoded allocations are capped at 128 MiB; aggregate normalized bitmap storage is capped at 1 GiB, with each tag's virtual stream smaller than 512 MiB. Actual allocation and GPU texture-size support remain required, especially on mobile devices. Linear textures must be two-dimensional, unmipped and uncompressed. Audio permutations are capped at 64 MiB of input and 16,777,216 decoded frames, with at most 256 MiB of converted audio.
- Reusing stock schemas and gameplay/render systems does not implement every MCC engine extension. MCC-only object behaviors, new shader semantics and UI callbacks require separate semantic work and representative maps. Embedded MCC widget event bytes are preserved: compatible callback IDs use the existing engine functions, while identified MCC-specific actions dispatch through the MCC adapter. This remains relevant to script-opened custom interfaces; the default pause menus use the separately generated definitions above. Unsupported embedded callbacks fail without performing the event's close/open actions. Native Settings is available in all MCC modes with one local player. HUD placement normalization and overlay handling still require visual comparison against the map's intended appearance.
- No claim is made here of complete campaign/gameplay fidelity or synchronization under all conditions, performance parity, or tested Android/Linux runtime behavior. See the bounded test status below.
The supplied MercuryRising/halo1/maps/a10.map was inspected without adding
its proprietary contents to the repository. Its observed inventory is:
| Field | Observed value |
|---|---|
| File size | 407,040,369 bytes |
| Internal name / build | mercury_falling / 01.06.66.HELL |
| Version / scenario type / flags | 13 / 0 (singleplayer) / 0x0007 |
| Tag base / bytes / count | 0x50000000 / 0x012D661C / 4,575 |
| Models / model parts | 153 / 842 |
| BSPs / BSP materials | 1 / 263 |
| Bitmap records / BC7 records | 1,122 / 38 |
| Sound permutations | 6,629, all embedded |
| Scripts / globals / parameterized scripts | 54 / 12 / 0 |
| Reserved syntax slots / active high-water count | 32,767 / 2,697 |
Deferred team-change deaths have their own records keyed by full player and unit handles. Only the matching no-statistics death receives neutral kill attribution before network replication; this preserves native respawn and objective cleanup without a Slayer suicide penalty. Tests include ordinary deaths, recycled handles, client authority and unloading the map.
The reported red/green Mercury cliff bands match the native allocation
failure texture: DEFAULT_BITMAP_PIXEL0/1 are transparent red and opaque
green. The captured stabbed.txt identifies the 2K cliff normal map as a
failed 22,369,664-byte allocation. Its source is a 5,592,432-byte BC7 mip
chain, expanded to ARGB for the native renderer. About 189 MiB of the
256 MiB staging cache was locked in that frame; its largest available
contiguous span was only about 11 MiB. Repeated retries explain the
associated stalls. The direct MCC binding above removes this staging
constraint. The reported black cliff faces are consistent with a failed
bump/lightmap sample, but the screenshots alone do not prove their cause.
A bounded native comparison rendered twelve camera angles at the captured
failure location. Both builds showed normal cliff textures in that fresh
run: the intermittent baseline failure was not reproduced, so those frames
are a regression check rather than a before/after reproduction. The fixed
Debug renderer also completed Mercury -> Xbox UI -> Xbox A10 -> Nitra ->
Mercury -> Xbox UI in one process without assertions, texture allocation
failures or stale-resource errors. The later generated-pause interaction
checks are described above; broader multiplayer and cooperative playtesting
remains necessary.
An independent script audit compared 748 live function calls, using 103
distinct function names, against the Xbox definitions. It found no
parameter-type drift for functions present in both. The only missing
Xbox names were the four vibrate-alias calls and six
objects_distance_to_object calls addressed above. Eight nonuniform
uncompressed cubemaps in the fixture confirmed mip-major storage (all six
faces within each mip): lower mip pixels matched upper mip averages to
less than 0.26/255 mean RGB error. Face-major interpretation produced
37�80/255 error. BC7 follows the same layout in the adapter; that particular
layout comparison did not independently test BC7.
The second supplied fixture, Nitra v2/dangercanyon.map, also passes the
parser and geometry harness. It is a 102,888,276-byte multiplayer cache,
internally nitra_v2 with build 01.03.43.0000. It has 2,353 tags occupying
5,911,224 bytes at 0x50000000, 55 models, one BSP with 139 materials, 731
bitmap records (no BC7), and 992 embedded sound permutations. Its 11 scripts
and four globals have no parameters. There are 244 high-water syntax slots,
173 live nodes and 56 function calls using 21 distinct names. The only name
missing from Xbox is the vibrate alias (four calls); no parameter-type
drift or missing engine globals were found. Geometry produces 1,112 buffers
and releases all of them.
Live Mercury loading now reaches the rendered world and runs its scripts
after passing media, tag and BSP validation. The validator corrects one
genuinely empty one-frame animation in
vehicles\falcon_destroyed\left_wing\one frame empty: both default-pose and
frame payloads are absent, so its node count becomes zero. This is not a
conversion that discards a present animation payload. A two-process Nitra
test ran 1,020 ticks and accepted ten remote hits with no rejected hits.
That run exposed a NULL-free assertion during geometry teardown; all
nullable geometry cleanup paths were guarded, and the harness now rejects
NULL frees like the native debug allocator. The corrected build subsequently
completed an MCC-to-Xbox-to-CE-to-MCC transition in one process without
rejection or assertions. Mercury save, revert and core reload accepted a
snapshot containing four nonzero extra grenade inventories. A two-process
Mercury cooperative run lasted about 1,320 ticks, ran opening scripts and
cinematics, and spawned both players alive at matching positions. Its host
core contained eight extra grenade records; the client's save request was
refused as host-authoritative. A final cooperative run lasted about 1,350
ticks and found the same eight nonzero type-2/type-3 inventories on host
and client, including exact salted handles, at 40, 50 and 60 seconds.
Both processes shut down cleanly and the client returned to the Xbox menu.
B40's first failing expression called core_save_name as a boolean.
The legacy Xbox function with that name returns void and writes a debug
save. H1A repurposed it for campaign segments, as documented in the
public scripting reference.
The MCC linker now gives this spelling its own boolean function definition
and the existing MCC segment evaluator. It logs the evaluated segment and
acknowledges it without writing a core file or contacting MCC telemetry.
The native Xbox/CE function table, compiler, validator and save functions
are unchanged. MCC console lookups use the same segment meaning; use the
existing core_save/core_load commands for an explicit debug core instead.
Solar Flare M1 exposed a later runtime failure that a startup check cannot
cover. Its five pilot/dropship recordings contain 0xFF00 in their initial
weapon selection field. The Xbox playback code reads this as the signed
short -256, outside the four-slot unit inventory. Triggering r_a_ds1 on
a_pilot in the published Windows release build 32 reproduced the reported
units.c assertions at original lines 1512 and 8371. The release's matching
symbols place the subsequent invalid object lookup in unit_can_use_weapon.
For a targeted reproduction in M1, create the pilot with
(object_create_anew a_pilot) and start (recording_play a_pilot r_a_ds1)
through the console. This exercises the control stream independently of the
mission trigger volumes.
mcc_recordings.c validates each recording stream before normalizing invalid
initial or event weapon selections to NONE (retain the unit's current
weapon). Valid slots 0 through 3 and the existing NONE sentinel are unchanged,
as are event timing, movement, flags and the remaining control fields. The
conversion writes only to the MCC loader's private tag buffer through
mcc_tags.c; it changes neither the Xbox playback interpreter nor Xbox/CE
loaders, unit code, inventory limits or network messages. Unsupported or
truncated streams are refused with a recording-specific diagnostic;
explicitly disabled empty recordings remain disabled.
Generated regression fixtures cover both playback codecs, all supported
control versions, selection events, truncation at every byte, unknown formats,
idempotence and checked scenario pointers/counts. A private audit of 377
recordings across the 17 supplied MCC maps found no parsing failures. It
normalized 23 invalid selections: five in each Solar Flare map, one in Combat
Revolved's credits and two in its D40. No map contents are included in tests.
The native startup checker now also treats EXCEPTION assert as a failure,
even if the process subsequently exits normally.
Run the isolated tests with a C compiler and Python/pytest available:
python -m pytest -q tools/test_mcc_cache_format.py tools/test_mcc_geometry.py
python -m pytest -q tools/test_mcc_tag_validation.py tools/test_mcc_checkpoint.py
python -m pytest -q tools/test_mcc_share.py tools/test_mcc_share_metadata.py tools/test_mcc_share_rules.py
python -m pytest -q tools/test_mcc_share_stage.py tools/test_mcc_share_storage.py
python -m pytest -q tools/harness -k mcc
Set MCC_TEST_MAP to an existing map path to opt into the real-fixture
checks. The parser tests are portable; the geometry harness currently
requires the x86 Windows game headers/toolchain and skips elsewhere.
port/tools/mcc_cache_report.c builds with mcc_cache_format.c and only
the C standard library, so files can also be audited outside the game.
None of these commands downloads or bundles a game map.
The MCC function registry also supports print_if, bitwise_and,
bitwise_or, bitwise_left_shift, bitwise_right_shift, bit_test,
bit_toggle, objects_distance_to_flag and sound_impulse_predict.
The integer operators use defined unsigned 32-bit operations; right shift
fills with zero. Negative shift counts produce zero, while nonnegative
counts use the low five bits. Bit-test/toggle use a bit position, and
toggle's third argument selects set or clear. The prediction function
requests all sound permutations from the existing sound cache without
playing them or consuming random numbers. Its boolean selects a blocking
request. Public signatures and the supplied compiled scripts were checked;
this is not an exhaustive comparison with every MCC runtime edge case.
When referenced, developer_mode is linked to an MCC scenario-owned short
global, initially zero. Script reads, writes and native checkpoint storage
therefore work without adding a global to the Xbox interpreter or enabling
engine developer privileges. Loading a different scenario discards it.
MCC HUD anchors 5 through 8 (top, bottom, left and right center) retain their authored values. MCC-only drawing handles their position, bitmap bounds and number alignment using the current player's window. The native anchor enum and its five existing cases are unchanged. Combat Revolved's unit HUD uses anchor 5; previously the native schema clamped it to top left.
Oversized MCC terminal fonts are scaled at draw time to a 15-pixel line at the engine's 480p reference resolution. The supplied Combat Revolved font has a 33-pixel line. This affects only the console input/output, including wrapping and line spacing; it does not resize HUD text or modify font tags. Xbox/CE paths and MCC fonts at or below the nominal size remain unchanged.
MCC maps may now contain up to 32,767 named objects. Maps with 513 or more
names use mcc_object_names.c; maps with at most 512 names retain the native
table. Xbox and Custom Edition keep their existing limits, allocations and
validation. This extends script names without increasing live-object
capacity. The scenery palette is extended separately below. Counts above
32,767 are refused explicitly; script targets are never dropped to fit.
The separate table follows creation, naming, deletion, restart and map unload. An MCC checkpoint stores the table in a checked unused part of the native save image, alongside the existing MCC state. Its length, checksum and object handles are validated before restoration. Checkpoints for smaller MCC maps retain their existing format. A save without enough unused memory is refused rather than overwriting engine allocations.
Singleplayer uses the table locally. Network games use OpenCE's existing host-authoritative replication for units and items, and MCC-only bounded presence messages for named scenery and devices. The host sends chunks of 512 names every half second. The client requires two distinct matching updates before creating or deleting an object; packet ranges, padding, map name count, BSP and timestamps are checked. These messages work in co-op and multiplayer and require network version 34 on every peer.
B30 Evolved's 640-name list is retained. Its script refusals were traced to
writes to f0-f4, sound_enable and map_reset, and are resolved:
- MCC
f0-f5references use private scenario real variables initialized to zero. These script counters survive checkpoints without changing the native renderer's debug controls. Appended names preserve the console's separate 1 KiB text reserve. sound_enablecontrols an MCC map-local mute, including music, carried in the campaign snapshot's flag bit 3. It preserves player volume settings, survives checkpoints, follows the host, and clears on map disposal.map_resetuses the existing restart operation: a local reset in singleplayer, and the MCC action adapter's reliable round restart in a network game. A client cannot request it through this script function.
B30 Evolved also exposed two rendering problems, handled only for MCC:
- The CMT fluid-burst effect spans more than the native eight bitmap pages.
mcc_sprites.csubmits each full batch through the existing renderer and starts another with the remaining sprite budget. It retains the native eight-group structure, shader, bitmap pages and first-person projection; excess pages are not silently discarded. - A signed object function can produce an intermediate RGB color below zero. MCC's object adapter preserves RGB extrapolation so the native object code can apply darkening and its existing final clamp. This avoids the native interpolation helper's premature assertion, without clamping the function itself or changing Xbox/CE interpolation. HSV interpolation is unchanged.
MCC scenery palettes also retain up to 32,767 entries. The original 100-entry limit is an authoring/schema limit: placement and synchronization already read the palette's dynamic tag block through checked signed-short indices. Only the MCC validator raises it; Xbox/CE schemas and live-object capacity remain unchanged. Oversized or out-of-bounds blocks are refused, and invalid placement indices retain the existing validation behavior. B30 Evolved's 101st entry, referenced by scenery placement 1997/name 639, is no longer truncated. A hidden Windows test created this entry, and a two-instance co-op test verified its creation, deletion and recreation after a reliable scripted restart on both peers. A checkpoint retest restored this same name 639 and the private script counter, restarted the map and returned to the menu without assertions. An earlier timed probe missed its expected checkpoint values; the focused retest produced both explicit success markers. This does not claim a complete campaign playthrough.
The supplied M0 has a 100-degree field of view in camera cin_x4 (index 3).
The native scripted camera and observer accept at most 90 degrees; the
observer also clamps its output to that maximum. The reported assertions
were reproduced as that camera became active. MCC metadata conversion now
limits wider, valid cinematic lenses to 90 degrees and logs the camera
index. This narrows those shots; it does not implement wider cinematic
lenses. Zero still selects the native default, and already supported
angles remain unchanged. Invalid angles (including NaN and infinity) and
out-of-bounds camera blocks are refused. Only the in-memory MCC copy is
changed; the map file and Xbox/CE camera code are untouched.
M0's cin_a script calls game_won at the end of its cinematics. In local
play, an unknown campaign level previously fell through to the Xbox credits
movie immediately after loading and precaching the menu. A separate access
violation was reproduced through menu -> M0 -> menu, even after fixing the
camera: the cache worker was copying a pending read into protected cache
memory during that movie transition. The matching Windows symbols identify
read_at / ReadFileEx / cached_map_issue_async_request on the failing
thread. Direct startup into M0 did not reproduce this second failure.
MCC scenario completion now queues the ordinary return to the menu, without
starting the Xbox campaign outro. Its helper lives in mcc_main.c, selected
by one additive dispatch in main_roll_credits. When MCC is inactive the
original statements execute unchanged. The existing network co-op win
branch still returns to its lobby before this path. No network message or
compatibility-version change is involved. This is an MCC-specific avoidance
of the credits/cache interaction, not a general change to the movie player
or background I/O. Xbox and CE completion remain unchanged.
At the time of that fix, automatic MCC campaign progression was unsupported. Packages without an enabled explicit campaign manifest still require manual mission selection. An unrelated saved-map identity rejection is normal, and the map's equipment/grenade warnings are not suppressed here.
Startup profile cleanup can enumerate directories concurrently, so MCC discovery owns and closes a platform directory handle of its own, without touching the Xbox or CE catalogs.
The MCC function table additionally supports list_count_not_dead,
script_finished, game_time_authoritative, sound_get_effects_gain, and
sound_set_effects_gain. Living-object counts skip dead and stale objects.
script_finished checks the named script thread's completed state; dormant,
sleeping, and unknown scripts are not reported as completed. The authoritative
clock uses local/server game ticks, or the latest received host tick on clients.
Effects gain is an MCC-owned multiplier (default 1, accepted range 0�4).
It affects non-music sound classes without changing saved user volume settings.
The small additive connection in the common sound mixer returns a neutral
multiplier outside an active MCC campaign. The MCC writable-global whitelist
also permits object_light_ambient_base, object_light_ambient_scale,
loud_dialog_hack, and ai_debug_ignore_player. Original values are captured
and restored when MCC unloads. AI-ignore changes remain host-authoritative.
The existing Xbox/Custom Edition global tables and script implementations are
not extended or replaced.
These values accompany the existing MCC campaign checkpoint/network state. The version-2 campaign snapshot is 764 bytes; version-1 752-byte checkpoints are migrated with defaults for the added state. Network compatibility advances from 27 to 28: all peers must use matching versions, including when playing Xbox or Custom Edition maps. There is no separate MCC transport or matchmaking.
Boom, Sputnik, and Catch skull globals report disabled. Literal assignments
that keep them disabled are accepted; enabling them or computing an assignment
is refused rather than pretending their gameplay effects exist. Similarly,
object_prediction reports enabled and accepts a literal enable only, matching
the existing engine prediction policy. Converted constant expressions preserve
their expected result types, including a void result for a set statement.
Several data corrections are confined to MCC conversion:
- An animation graph's unused root sibling is cleared only after validating the reachable child tree and parent relationships. Orphans and child cycles still fail validation. This handles DP's brute graph.
- Invalid model tangent frames can be reconstructed from valid geometry and UV derivatives. Degenerate UVs use a deterministic perpendicular basis. Invalid positions, normals, UVs, or indices still fail; valid frames are retained. This repairs ML's pelican data without modifying the source map.
- Shared-resource lookup can resolve a relocated payload by a unique full resource name and exact size in the supplied cache's validated directory. Duplicate names, size mismatches, and invalid ranges are refused. This is structural validation, not a content hash: supply the correct package's resources. Mercury Falling needs this for a relocated footstep sample.
- A reference with neither its own nor its group's name in the package's own resource file is found at its offset when it spans exactly one whole member, as MCC reads it: a map whose resources were built with a tag since renamed or moved keeps its sounds and bitmaps. Part of a member, or a slice across members, is still refused; a bitmap's decoding then reads from the member's start within it (its pixels may be fewer than the member's bytes). A shared resource file is never matched this way: the same offset and size in another file says nothing of which file the map was built with, so choosing among shared files still goes by names alone.
- Non-power-of-two 2D bitmaps retain their dimensions in a linear ARGB texture. Their declared source mip chain is validated, but only the base level is retained because the native linear texture path has no mipmaps. This handles Aerowalk's 1920�1080 HUD bitmap.
Judgement's game_time_authoritative conversion is supported, but the supplied
Workshop package declares InheritSharedFiles: FromMCC and references 687
external bitmap descriptors. It does not bundle the shared resources. The
available Aerowalk and Mercury caches do not contain all required textures;
the loader correctly refuses missing data instead of substituting unrelated
assets. A complete Judgement load requires its matching MCC shared resources.
Regression tests exercise actual MCC handlers, script conversion, snapshot migration, malformed resources, animation graphs, geometry, textures, and the sound-mixer connection. Native smoke tests use an isolated Windows data root, one hidden process at a time, and a console marker after 150 simulation ticks.
These are wire-format references, not copied implementation code. Current version-13 fields were checked against the supplied file where available; older CEA documentation sometimes describes different compression and memory limits and must not be applied indiscriminately.
| Fact | Primary source / observed check |
|---|---|
| Version 13, 40-byte PC tag header, 64 MiB tag capacity | Invader map definitions, engine configuration; fixture tag pointer 0x50000028. |
| Infer linked base from tag array; current v13 is uncompressed | Invader map reader; header and index read directly from fixture. |
| MCC BSP external environment/lightmap vertex streams | Invader BSP compiler, build layout, BSP schema; fixture header has 0x2B5D0C bytes at file offset 0x800. |
| BC7 format 18, environment flag bit 9 and external resource flag bit 8 | Invader bitmap schema; fixture contains 38 BC7 records and environment-flagged bitmaps. |
| MCC script parameters, expanded syntax capacity | Invader scenario schema, MCC editing kit change documentation; fixture syntax is 56 + 32767 * 20 bytes. |
| MCC Halo 1 syntax limit is 32,767 | Invader engine configuration uses INT16_MAX; all ten Ruby map headers reserve exactly this count. |
| Mission-segment boolean/string contract | Sapien's generated function documentation and shipped MCC c10 scripts; Ruby's 225 calls also take one string, with boolean conditions used before sleep. |
| Parameter wire records and local references | Scenario schema defines 36-byte records, maximum 16 and local-variable flag bit 4; public script compiler confirms primitive/global/local flags and the parameter slot in node data. |
| Sound compression formats and cached sound data | Invader sound compiler, existing Xbox sound definitions; fixture samples and tag fields checked directly. |
| MCC HUD canvas and independent bitmap half-scale | Restored tagset author's format notes; Ruby shield offsets and number advances are exactly twice their stock Xbox counterparts. |
| Xbox-order model and HUD meter flags | Invader model shader schema, HUD meter schema; Ruby and Mercury contain mixed flag states. |
| Empty Vorbis residue vectors contribute zero | Xiph Vorbis 1.3.7 codebook implementation, vorbis_book_decodevs_add, vorbis_book_decodev_add, vorbis_book_decodevv_add; synthetic multi-pass streams and independent Ruby PCM comparison. |
| Header and historical format differences | Reclaimers map documentation, SnowyMouse CEA format research; historical chunk compression is outside this implementation's scope. |
Gameplay A/B/X/Y use the embedded OpenCE redraws with compact text-fragment
spacing. The modern shoulder labels use Xbox white (LB) and black (RB),
matching xinput_sdl.c; the two neutral variants reuse the button redraw's
oval. Other controls and custom pickup artwork retain their existing path.
Pause menus are unchanged. All replacements are selected by controller-entry
identity, never by a shared sprite sequence number.
A50_Revisited mixes legacy high-resolution placements with unflagged visor and number placements. Halving every anchor offset compressed the ammo layout, moved the flashlight meter toward the centre, and overlapped the shield panel with the visor. Preserving the flagged offsets corrects those relationships without map-name checks or changing the Xbox/CE renderer. MCC anchors also use a 2.5% title-safe inset, matching the supplied reference, rather than Xbox's 7.5%; this keeps the flashlight above the bottom visor. Centre-anchored crosshairs and the inner split-screen seam retain their existing calculations. The supplied Workshop reference and a hidden native-renderer capture were used to compare the visor join and ammo layout. A separate bounded capture enabled the flashlight and verified its meter above the bottom visor. Regression cases cover split-screen seams, zoom inset preservation, controller mappings, and neutral Xbox/CE dispatch.
- Bigass calls
abs_real. The MCC adapter implements real-valued absolute value, including negative zero, without changing native functions. - Warthog Rally passes short script parameters and globals where long integers are expected. MCC validation and evaluation now agree on signed widening. Invalid signatures and scopes still fail with more specific diagnostics.
- BioHalo deduplicates same-group tag roots and shares structured blocks, prefixes, names and data streams. The MCC validator tracks compatible allocations and isolates overlapping scalar, empty and selected raw-data records before correction. Bounds, schema, cycle, depth and traversal-budget checks remain enforced. Nonzero pointer-bearing partial overlaps are refused.
- Canyon and Canyon-plus contain a 15360-by-256 DXT1 effect strip. Converted linear pixels use an MCC descriptor with dimensions and pitch beyond the Xbox header's fields. Their 8192-pixel texture also exposed a too-small Morton address table in the MCC converter; its capacity and bounds now agree. The MCC-only GPU uploader checks the device's actual size limit. Hardware unable to upload the strip does not gain support through downsampling.
- Cursed Halo's Sophia animation graph lacks its parent hierarchy. Recovery requires an associated model with identical ordered node names and agreement between multiple associated models. The recovered tree still passes normal validation. This fixes the graph rejection, not all campaign features.
- MacWorld's Elite model references material 14 with only 14 entries (valid indices 0 through 13) on geometry 40, part 2: an 88-vertex damaged torso. All supplied campaign variants have the same missing entry. With explicit approval, MCC conversion applies the engine validator's existing material-0 fallback and logs the tag, geometry and part. Geometry remains present; the intended appearance is unknown and may differ. Empty material lists and invalid geometry buffers are still refused.
These are MCC-owned changes. The sole shared renderer edit extends the existing MCC upload function because the game-side converter cannot query OpenGL device limits. Xbox/Custom Edition texture paths, script permissions and network messages are unchanged. Validation bookkeeping uses the game allocator's matching allocation/free pair, including cleanup when leaving an MCC map. The regression harness now checks this allocation pairing too.
Resource investigation found two distinct MCC bitmap files. The direct
halo1/maps/bitmaps.map contains Mirror of Autumn's pipe texture at offset
52930688 (10936 bytes), and Warthog Rally's swamp bark at 146997993 (43704 bytes),
matching their references exactly. Those names are absent from MCC's
halo1/maps/custom_edition/bitmaps.map. Selecting by game mode or assuming
the two files are interchangeable would therefore be incorrect.
The existing MCC cast hook now also handles short-to-long widening for globals; parameter-only handling was insufficient when Warthog Rally compiled its timer expression. The guarded hook is necessary because native expression compilation and evaluation use the shared interpreter. Xbox and Custom Edition retain the original cast table, and the tests cover the inactive-MCC case. At this stage Cursed Halo loaded after graph repair, but 15 scripts remained disabled because of restricted engine cheats (vehicle spawning, jetpack, super-jump, possession, Medusa, bottomless ammunition and omnipotence). The new diagnostics identify individual scripts. No cheat permission or client-authority restriction is bypassed; this fix does not certify Cursed Halo as playable.
The selected resource streams are retained through conversion. Map admission,
conversion and checkpoint identity use the same dependency selection. Required
resources contribute to the fingerprint regardless of their installation path;
unused resources and loc.map do not. Network version 36 prevents older peers
from using the previous fingerprint rules. Existing MCC checkpoints can become
incompatible when their resource fingerprint changes. This is a consistency
check, not authentication of a client or a map's contents.
Bigass's HUD globals omit defaults.default_weapon_hud (reference at 0x2C0,
handle NONE). A joining multiplayer client can briefly have a living unit but
no weapon before replication completes. The native unarmed HUD update then
tries to resolve that missing handle, causing cache assertions and repeated
parent-HUD traversal. The MCC converter supplies one owned, empty weapon HUD
only for omitted defaults, with no parent or visual elements. Authored defaults
remain unchanged and invalid nonempty references still undergo validation.
No shared HUD or networking code changes are needed. The generated tag has the
same deterministic identity on both peers and is released with the MCC cache.
Tests cover reuse, authored defaults, tag capacity and allocation failures.
MCC weapon flags bit 17 (0x20000) requests a third-person camera, as
documented by https://c20.reclaimers.net/h1/tags/object/item/weapon/.
Spasm Playground uses it on its Digsite weapons; its player bipeds carry
a single authored camera track. mcc_camera selects the native following
camera and its existing unit/default track, interpolation and collision
handling. Unflagged weapons and zoom use first person; existing seat,
cinematic and death camera handling takes precedence. This is independent
of the optional OpenCE third-person mode and has no toggle or preference.
The additive hook in director_desired_perspective is necessary because
both camera selection and deterministic aiming use that shared function;
there is no registered camera-selection extension. The MCC adapter checks
the active map before reading inventory, holds no state across map changes,
and leaves Xbox/Custom Edition paths unchanged. Existing host-controlled
inventory synchronization is sufficient, but network version 38 prevents
peers with the previous aiming behavior from joining.
The MCC bitmap adapter permits up to 2 GiB of converted texture storage per map. Individual allocations remain limited to 128 MiB, and each tag retains its existing bounded virtual stream. Allocation failures refuse the map with a diagnostic; the larger budget is not a guarantee that every platform has enough free address space or memory. Unconverted pixels no longer require an extra intermediate copy. The MCC bitmap-group callback checks owned converted allocations and sequence ranges instead of applying the legacy file-backed bitmap budget, which would otherwise empty XAM's 4096-pixel textures. Xbox and Custom Edition retain their own validation and storage limits.
XAM A30 additionally has a graph with all links omitted and several graphs with missing parent indices. Fully omitted links can be recovered only from an associated model with matching ordered node names; associated models must agree. An omitted parent can be derived from an explicit child link only while validating a complete, uniquely reachable tree. Flood Forgotten Exile's Flood Banshee has a separate pattern: its root names the last sibling rather than the first child. Recovery requires matching names and every non-root link to agree with the associated model. Conflicting links, cycles and unreachable nodes remain rejected. Repairs are logged and confined to converted MCC tags.
The MCC-only zero-argument, void cinematic_abort adapter schedules OpenCE's
existing cinematic skip operation. This preserves its skippable-checkpoint
requirements and host-controlled co-op revert. A network client cannot invoke
that operation through this adapter. No new packet or client authority is
introduced. The signature is documented at
https://andrew.gg/scripts/00reference.html; the evaluator mapping to cinematic
skip is independently documented at
https://surreptitiousresearch.github.io/halocea_docs/21_script_presentation.html.
Implementation uses the existing OpenCE interface, not MCC implementation code.
All implementation changes are in MCC modules. No shared engine source, Xbox/Custom Edition loader or network message layout was changed. For authored biped seats and their network isolation, see MCC seats.
mcc_script_effects.c supports the map-authored jetpack, super-jump,
bottomless-clip, possession, Medusa, omnipotence and deathless flags. The
MCC campaign adapter also exposes vehicle spawning through the existing
engine service. This enables the 15 previously restricted Cursed Halo scripts;
it does not add Twitch/Crowd Control connectivity. Evidence comes from the
supplied CursedHalo A10's compiled scripts: its dispatcher calls timed fx_*
scripts, whose continuous updates clear the flags when their timers expire.
No proprietary MCC source was used.
The host runs these scripts and owns damage, spawning and possession. Clients receive bounded effect flags in the existing MCC campaign snapshot and use them for movement and ammunition prediction, while native client cheat globals remain disabled. Jetpack and super-jump keep movement host-simulated from validated inputs rather than widening acceptable client position/velocity bounds. This can require corrections under latency; it does not authorize a client's position, possession target or cheat request. State version 3 retains the snapshot size and accepts older checkpoint versions with the new effects off. Network version 40 is required because peers must agree on these effects and on live-body player transfers.
The shared hooks are necessary because the native movement and weapon code
reads cheat globals directly, the bump handler uses a local-only possession
helper, and client player attachment previously killed the former body.
Guarded calls in bipeds.c, units.c and weapons.c consult MCC-owned state;
network_distributed.c leaves MCC former-body death to host replication and
declines client movement corrections during movement effects. Their inactive
MCC paths retain Xbox/Custom Edition behavior. Effect state is restored at
checkpoints and the pre-MCC settings are restored on unload.
The same A10 intro passes an actor-variant tag to object_type_predict.
The MCC adapter precaches that variant's referenced unit after group checks,
instead of interpreting actor-variant data as an object. Other non-object
references produce a diagnostic; the native function is unchanged.
Final Windows executable SHA-256:
f2c16365d22ab7c5d84f7ffcbd400f3ec0b62e6ff9638cc2979b859e20809f8c.
game_speed_value is linked to an MCC scenario-local real global, initialized
to one. Its read/write adapter uses the native host's game-time speed, which
already belongs to saved game state. Finite values from zero through 100 are
accepted, matching the native speed setter; this is a safety bound, not a
recommendation to run maps at high speed. The public
H1 scripting reference documents
the MCC global and warns against speeds above 20. No reporter could identify
the original failing map, so runtime validation uses private copies of
Bigass and Mercury Falling with this global added; originals remain unchanged.
mcc_game_speed.c owns synchronization and client state. Only the host may
change speed. Clients retain the native cheat enforcement and receive a
separate multiplier from the host on its reliable, ordered connection.
Message 90 requires exactly one float, an exact packet size and the host
connection; unreliable packets and client senders are rejected. Invalid float
values are ignored. Updates continue in wall-clock time at speed zero, and
repeat for joining clients. They are deliberately outside the tick-only batch
and stale-tick filter, so pause/resume and checkpoint rewinds remain possible.
Network version 41 is required for this new message and timing agreement.
The existing engine admits new players on simulation ticks: joining a host
already at speed zero can time out before admission. Resume before admitting
a new player. Existing players can pause/resume together; a late join at half
speed also receives the correct multiplier. This change does not alter the
shared player-admission implementation.
The host's existing client speed-hack detector still runs. Its elapsed time uses an MCC-owned clock integrating only host-approved speed changes. At zero speed it retains a small positive budget rather than exempting clients. Client movement acceptance and other host-authority checks are unchanged. MCC unload and new-map initialization clear remote speed and send/clock bookkeeping.
The interpreter's global reconciliation and the frame/tick clock read native
state directly, so MCC modules alone cannot implement these semantics.
Small hooks in hs_runtime.c and game_time.c invoke the MCC adapter;
network_distributed.c adds dispatch and a clock query. Xbox/CE lookups and
clock behavior retain their original values when the MCC guards are inactive.
Bigass's day, night and snow maps each contain 21 environment shaders with
flag 0x8, including altis\\levels\\bigass\\shaders\\bigassgrass in the day map.
The environment shader format reference
identifies this as alternate bump attenuation, correcting repeated diffuse
attenuation that can darken terrain and expose triangle boundaries. The flag
layout is corroborated by Invader's public shader_environment schema. No
proprietary shader implementation or SDK material was used.
mcc_environment_shader.c scopes this behavior to a flagged MCC lightmap
draw, excluding specular-mask-only bump maps. The platform companion emits
an independently reconstructed response: max(0, 1 + dot(normal, light) - light.z), followed by the existing combiner clamp. A flat normal therefore
preserves the baked lightmap response instead of attenuating it again, while
normal variations still affect it. This is an approximation of the documented
intent, not a verified copy of MCC's exact shader equation. The supplied
native MCC screenshots establish the visual symptom; controlled
same-camera comparisons show the reduction in dark terrain triangles. Exact
brightness in every MCC material remains a playtest limitation.
This cannot be implemented purely by changing converted texture bytes: it depends on the incident-light vector of each fragment. The necessary shared additions scope the environment draw, carry one bit in the compiled shader cache key, and select the MCC emitter only for the matching bump-dot combiner. All other combiners retain the original generator. The draw clears its state immediately afterward, so subsequent materials and map families cannot inherit it. No texture, global brightness, Xbox shader flag or CE loader is rewritten.
The native pregame client polls map readiness once per second. The MCC hook previously reread tag data and fingerprinted every required resource on each poll, blocking menu frames. Mercury Falling's supplied bitmap and sound resources total roughly 687 MB; repeated reads reproduced the reported stalls.
mcc_precache.c retains one successful readiness result while the map and all
eight possible bitmap/sound resource candidates have unchanged file metadata.
Missing candidates are recorded too: adding a package override or another
shared resource set invalidates the result. Size, creation/write time and
attribute changes trigger full validation; access time does not. Failed
validation is never cached, unreadable metadata prevents reuse, and a change
during validation cannot establish a cached ready result. Rescanning the MCC
catalog and unloading MCC tags clear the result.
This is a polling optimization, not a trusted content fingerprint. The original issue #51 fix left network admission, map-version calculation and actual loading on independent resource validation paths. The issue #74 extension below reuses unchanged checksum validation between the first two paths; actual loading still validates independently. Neither change alters host-authority rules or wire values.
The existing MCC branch in cache_files_give_time_to_precache must select the
new polling function because its old callee also serves admission callers,
which retain their admission checks. This was the only shared-engine change
for issue #51. Xbox and Custom
Edition readiness branches retain their existing code and behavior.
Selecting a resource-backed MCC map computed its resource checksum, then computed it again for local admission and the first readiness poll. The separate readiness cache did not cover those calls, and opening the map browser invalidated readiness even when no files changed. These synchronous reads can stall the menu while it is open or returning to the lobby.
The original issue #74 fix made mcc_cache_probe retain one successful checksum with the complete
mcc_precache_snapshot. Every reuse checks the name and all nine file stamps;
failed validation or unavailable metadata cannot populate the cache. A change
while validating refuses the result. The requested network checksum and admitted
SHA-256 identity are still checked on every admission. Unload and disconnect
clear the result, while catalog rescans can safely reuse unchanged inputs.
The loader still validates the opened resources independently. All changes are
in MCC-owned modules; no Xbox/CE implementation or network wire value changes.
That initial fix also opened loading feedback for uncached probes. It was
insufficient: disconnect cleared the result and a settings send during teardown
could prepare the host identity again. Selecting a map also checked readiness
synchronously through main_set_multiplayer_map_name.
The follow-up keeps host preparation in MCC-owned pregame updates. Menu actions schedule a check, host readiness polls completed results, and settings sends never initiate validation. A cancellable worker checks complete CRC and SHA-256 values using only private file readers, with incremental pregame work as a fallback when a worker is unavailable. Early start requests wait in pregame; four successful file-stamped results survive session teardown, while session bindings and unfinished readers are cleared. Any changed resource candidate invalidates reuse. Actual loads retain their independent content checks and loading display. The renderer, preparation settings, Android protections and Xbox/CE paths are unchanged. See the reader's guide for the call path, slice limits and lifecycle. The measurements below describe the original fix, not validation of this follow-up.
The build-111 executable and its matching published PDB resolve issue #63's
fault to object_get_and_verify_type, called by unit_kill_silent from a
scenario script. The datum is NONE. Mercury2's bsp_switching_credits
script kills three named scientist units, which may be absent; this is a
plausible call site, not confirmation of the reporter's playthrough location.
Calling (unit_kill_silent none) in the original build reproduces the same
fault and relative instruction address. Tiny Halo's startup independently
reproduces the corresponding unit_kill fault before its player proxy exists.
The public c20 script reference
also documents the pre-MCC crash when either command targets a missing unit.
The MCC campaign adapters now evaluate the argument normally, preserve a yielding evaluation, and validate the full datum and unit type before calling the existing kill routines. Missing, stale and non-unit targets return without a kill. Valid units retain the existing death behavior. Execution requires an active MCC cache and local/host authority. The kill adapters do not change any Xbox or Custom Edition function table, evaluator or shared-engine source. The new entries are appended to preserve existing MCC function indices. There is no new state or message to synchronize: scripts run on the host and deaths use the existing replication. These adapters alone do not require a protocol change; the recording policy below does require matching MCC peers.
Tiny Halo's two 78-byte version-4/control-version-4 weapon-switch recordings have zero throttle and all three initial direction vectors zero. Their only effective event changes the weapon slot, followed by a timed end event. Preserving the unit's current directions is an explicit compatibility policy for this non-directional input, inferred from those inspected streams and their weapon-switch script use; it is not a claim to reproduce MCC's private playback implementation. The converter logs which recordings use the policy.
The existing bounds-checked MCC recording walker recognizes this case only when the entire stream through its end is valid, initial control flags and movement/direction vectors are zero, and it contains a weapon event with no other effective event type. Signed zero is accepted. Authored directions, motion, control/animation-state events, older codecs and malformed streams do not select the fallback. Recording bytes, event timings, weapon slots and the remaining controller fields are not rewritten by this policy.
mcc_recording_control.c initializes only the playback controller's three
directions from the target unit's valid current orientation. It requires an
active MCC cache, MCC-owned stream storage and a valid unit. A minimal port:
hook in recorded_animations.c supplies its private controller immediately
after native decoding. Conversion alone cannot supply a live unit orientation:
the same recording can be played on different units facing different ways.
The hook returns without changing anything outside MCC or for ordinary
recordings. It adds no persistent state or allocation to leak across reloads,
checkpoints or map-family transitions. Existing playback still owns the
recording's lifetime, possession, events and completion.
In co-op the host continues to initiate scenario/AI recordings; existing unit controls and object synchronization carry their results to clients. Multiplayer clients can also run local scripts, so MCC protocol 46 requires matching recording behavior on both peers. No packet layout or client authority was added, and the OpenCE/Xbox/Custom Edition protocol remains 29. The asset-free tests exercise the production walker and runtime hook, including every stream truncation, nonzero/NaN/infinite directions, other event types, distinct current directions, invalid units, foreign data, and inactive-MCC behavior. The combined focused suite passed 188 tests.
Mercury2's Doozy uses the three-powered-point boat controller. Its inspected
crashsite\levels\splashsite\doozy\doozy physics tag (index 3733 in the
supplied map) has finite mass/inertia data and water-friction plus water-lift
flags (0x0a) on all three powered points. The engine's boat controller
assigns water_friction_velocity only on point zero; physics_compute_new
reads it on points one and two as well. Those stack values were uninitialized.
A non-finite value can contaminate the boat's force, position and orientation;
the issue reports precisely those invalid vectors. This also explains why a
client's earlier visible copy cannot be boarded on the authoritative host.
update_human_boat_physics in source/units/vehicles.c zeroes the three
temporary controls before assigning its rotations, lift and propeller speed.
This shared producer correction replaces the former MCC-only initializer.
Conversion alone cannot initialize this private per-tick stack storage. The
native engine accepts the same powered-point flags, so Xbox and Custom Edition
boats need the correction too. Other vehicle controllers and boat point counts retain their paths.
No authored tags, network permissions, packet fields or seat rules change.
There is no persistent state to clean up across map-family transitions.
The original fix introduced MCC protocol 47 to require this initialization on every peer, including a client predicting a boat it drives; OpenCE's separate protocol was then 29. The current agreements are recorded in NETCODE.md.
The boat harness extracts the real controller, scratch structure, force consumers and linear integration. It uses non-finite and finite stale control values, checks observable forces, active controls, alternate point counts and adjacent storage, and removes the initializer in an isolated negative control. Its world queries and transforms are controlled fixtures; this is not a complete vehicle simulation.
The refactor audit confirmed that this is a general controller defect, rather
than an MCC layout difference. vehicle_update in
vehicles.c allocates the powered-point array on
each call. Its boat branch assigns all rotations and lift ratios but only
point zero's water-friction velocity. Native vehicle validation accepts boat
type 2, and native physics validation accepts three powered points with these
flags. The unchanged functions in
physics.c consume those controls independently
of map family. They clear the separate mass-point output array and derive
rotation matrices; neither action initializes the control scalars. No prior
tick's state belongs in this local array.
The new reproduction feeds identical accepted content through the controller and force consumer with MCC inactive and active. With MCC inactive, poisoned hydrofoil controls produce non-finite forces or incorrect finite friction. The current MCC initialization avoids both failures. This establishes a class of supported inputs, without a map name, checksum or asset selector; it does not establish that stock Xbox maps contain such boats.
The minimal shared correction initializes exactly three records inside the existing three-point branch, retaining its arithmetic and the other-count fallback, and retires the MCC helper. Clients predict driven vehicles, so the shared correction requires updated peers through the agreements documented in NETCODE.md. It is independent of optional camera mode and map identity.
The twelve historical legacy failures are now ordinary passing regressions.
Isolated mutations reintroducing the MCC guard reproduce the defect;
adjacent
storage, active controls and alternate point-count checks remain. Source
inspection also found the omission in upstream fc9deb0b1; no unmodified
upstream compatibility is claimed.
Issue #76 reports truncated
Warthog Rally titles. Inspection of the local warthog_rally.map found 17
scenario titles, all centered, with horizontal bounds 240..400 and text flags
zero (no wrapping). The gold title references the complete trophy message;
its string is not truncated in the map. A hidden Windows run of bed24ca3
displayed only "You won the gold", confirming clipping at the authored box.
The MCC compatibility policy lets non-wrapping titles use the available screen width around their authored alignment anchor. This is based on the intact authored messages and observed clipping, not a claim that the original MCC renderer has been executed or precisely reproduced. Wrapped, inverted and already offscreen rectangles retain their bounds. Vertical layout, font, colors, fades, title timing and script/network state are unchanged.
mcc_hud_title_bounds in port/linux/game/mcc_hud_draw.c owns the adjustment.
The one additive call in source/cutscene/cinematics.c is needed after native
widescreen positioning: changing the tag rectangle at load time would also
change that positioning, particularly for left/right-aligned titles. The
helper returns immediately outside MCC and changes only the temporary draw
rectangle; no allocation, retained state or unload cleanup is needed. The
native text layout and Xbox/Custom Edition title implementations remain intact.
The asset-free title tests execute the real renderer dispatch and MCC helper, covering legacy bounds, wide screens, wrapping, alignment, tag immutability, and MCC-to-legacy transitions. A negative control removes the integration call and must reproduce the failure. These checks cover title layout, not full map compatibility or campaign completion.
The 2026-10-29 investigation used the supplied version-13 maps against testing
base bed24ca319abae84f1de99351642a8ba27710f09. The implementation stays in
MCC-owned modules, using existing engine interfaces. No Xbox/CE implementation,
map directory, native function table, network packet or checkpoint layout changes.
- Bot Bootcamp A10: its syntax node 8865 assigns literal true to
breadcrumbs_navpoints_enabled_override. MCC already exposes breadcrumb availability as true. This assignment and boolean reads now agree with that policy; computed assignments and disables remain explicit errors. - Bot Bootcamp D40:
characters\ai_bbcmp\aicyborgomits the neck-to-head child edge. Its associated cyborg model supplies that edge with matching ordered names and parents. - Arbiter's Demise DE1:
np\objects\vehicles\ghost\hr\ghostomits sibling edges and stores zero in every parent slot. Its associated model has the matching ten nodes and a complete hierarchy. Recovery fills omissions only when retained edges agree; the complete tree still undergoes cycle, parent and reachability checks. - Super Wacky Funtime Ultimate MCC Edition C20: the Flood collision model's
node 3, BSP 0, surfaces 3 and 5 name starts belonging to the other surface.
Their own four-edge rings are intact. MCC selects a start from each complete
owned ring, preserving all vertices, planes and edge links, then invokes the
existing collision check. Related models expose the same defect. The map also
uses
cheat_all_weapons; an MCC handler invokes the existing service only on the local game or host. Existing host object replication carries the spawns. - Halo CE Extended A30_2: sound tag 3267,
sound\dialog\infinite\perez\startle, has sample rate NONE and one empty pitch range. Its unused header is normalized without inventing audio. Nonempty unknown-rate sounds still fail. The next blocker was the old aggregate audio allocation reaching the engine's strict 256 MiB allocation bound. Conversion now retains separate tag-owned streams: this fixture converts 17,992 permutations into 401,105,808 ADPCM bytes. Cache reads already carry the full sound tag, and MCC validation now checks the same ownership. Individual streams stay below 256 MiB and aggregate allocated capacity is bounded to 1 GiB. All streams are freed on failed load and unload.
The new script entry is appended, preserving existing MCC function indices. The weapon operation uses an existing host-only service and replication format; audio offsets are local cache data, and newly recovered graphs retain their node indices. No new peer agreement or message format is introduced, so the native and MCC network versions remain unchanged.
Focused asset-free coverage exercises partial animation links, conflicting models and cycles, misplaced collision starts, incomplete rings, sound ownership and stale handles, truncated reads, unknown-rate payload rejection, allocation failures and teardown. The native sound harness compiles the real converter; codec-vector tests continue to verify its output. Campaign tests check weapon spawning on the host/local game, refusal on clients and after teardown, and restart. The reader's route is in Maps and resources.
Disposable map fixtures, generated caches and duplicate test binaries were removed. Useful logs were retained, and test saves were archived with their original relative paths and SHA-256 hashes; every archived entry was verified before removing its loose copy. The final Windows executable and debug symbols remain available for the coordinating chat. Original supplied maps and saves were not modified.
Remaining limitations established during this investigation:
- CE Third Person Armory enables I Would Have Been Your Daddy and Grunt Birthday Party. These skull effects are not implemented. The refusal now names the offending global and syntax node; accepting an enable as a no-op would change authored gameplay and is intentionally not done.
- PFD loads and advances simulation during a three-minute idle run, without
reproducing the reported post-transition crash. Its assault rifle and M4A1
reference the model shader
deathstar\project_subterfuge\shader model\tag_334as an object modifier. That shader kind remains unsupported in the modifier renderer, and the warning is retained. The original crash still needs a reproducible route or checkpoint; startup success does not resolve it. - Windows debug portable builds were used, with PGO and LTO disabled. These are bounded startup/simulation checks, not completed campaigns or visual parity verification. Android and web builds were attempted but their generated shell commands cannot run on this Windows host; WSL is absent. Platform integration must repeat those builds in a supported environment.
The supplied version-13 maps reproduce three separate admission failures:
Ruined Halo b30h3 at animation tag ea4008cc, Mission Z9 z9 at
abs_integer, and Halo RPG halo_rpg at kill_thread and
get_executing_running_thread.
mcc_scripts.c registers the three functions outside the native Xbox/CE
function table. abs_integer takes and returns a 32-bit long; negation uses
unsigned arithmetic, retaining 0x80000000 for the unrepresentable positive
absolute value of LONG_MIN. This edge policy is explicit and tested; no
observation of MCC's LONG_MIN result is claimed. The public
H1 script reference
documents the ordinary integer signature. Z9 calls it on the difference
between its marine count and ai_living_count.
Halo RPG contains 40 compiled self-termination calls of the form
(kill_thread (get_executing_running_thread)). The MCC runtime adapter
returns the full salted thread handle and checks that handle before cancelling
an invocation. It releases parameter-held object lists, clears the stack and
marks a scenario thread terminated, so ordinary wake cannot resume it.
Self-termination does not return through discarded frames. The native scheduler
still owns deletion of its current console thread. Invalid, unsalted, deleted
and stale handles do not cancel another thread. These operations add no external
state: thread state retains its existing checkpoint, restart and unload lifetime.
The previously supported named sleep_forever reset operation is unchanged.
Ruined Halo's graph reach\objects\vehicles\human\warthog\warthog
has 20 named nodes. Its root starts at suspension node 2, leaving cargo node 1
and its descendants outside the root's child chain; several of those descendants
also carry zero parent indices. All three objects referencing the graph point
to a model with the same ordered names and a complete hierarchy. The MCC
validator recovers incomplete chains only from agreeing associated models.
Nonzero retained parents must match, siblings must belong to the same parent,
children must belong to their stated parent, and cycles still fail. Zero parents
are treated as omitted only in this incomplete-chain recovery path. Complete
hierarchies are preserved. The recovered graph still passes full reachability
and permutation checks; no animation or vertex indices are remapped.
Mission Z9's watch_land writes rasterizer_model_lighting_ambient to
0.1, then 0. This is implemented by mcc_campaign.c, using the existing
native lighting global and renderer. A positive value selects constant model
ambient lighting; zero returns to ordinary model lighting. MCC captures the
pre-load value, restores it on unload and script startup (including map_reset),
and includes the live value in host-owned campaign snapshots. The existing
mcc_hs_threads_activate lifecycle entry calls the MCC lighting reset; no new
shared-engine hook or renderer branch is needed. Xbox/CE write permissions and
loading paths are unchanged.
Campaign state version 6 is 772 bytes, with the new real after the previous 768-byte version 5. Older checkpoint states default the absent lighting value to the captured pre-load value. Snapshot validation rejects nonfinite and out-of-range values. MCC protocol 63 introduced the larger snapshot on both peers while the shared agreement remained OpenCE 41. That was an MCC-only agreement change. The current shared checkpoint lifetime fix separately requires updated OpenCE 42 peers for every map family; see the current protocol boundary.
mcc_checkpoint.c keeps the existing 768-byte campaign reservation and all
thread/object-name arena addresses. Checkpoint footer version 3 uses four of
its eight reserved bytes for the lighting extension and four for a footer CRC.
It reassembles the full campaign snapshot for validation and restore. Versions
1 and 2 retain their original layouts and checks. Increasing the reservation
instead would invalidate pointers inside older saved thread stacks.
A longer Ruined Halo run also exposed a later particle-system assertion:
particle_system_new_particle_jet read constant index 2 from a two-entry block.
The supplied map contains two-entry jet types in dirt, blood and water effects,
and a needler type that selects jet creation in a later state. The pair contains
velocity and spread; the January engine additionally reads a rotates-up switch.
mcc_particle_type_constants preserves the pair and appends a false switch in
bounded MCC-owned runtime tag storage. Existing three-entry blocks are unchanged.
This is an explicit compatibility default, not a claim of verified MCC visual
parity. The same third slot is also used as intensity if a later state switches
to explosion creation; an absent slot defaults to zero there. Shorter required
blocks, invalid extents and allocation failures are refused before runtime.
The public Invader particle-system schema
corroborates the block layouts and mode values; this implementation was written
from the local engine consumer and inspected map data, without copied code.
These changes remain in MCC-owned modules and their tests. The host continues to run campaign scripts. Regression tests exercise the real linker, evaluator, validator, campaign snapshot and checkpoint adapters: integer limits, argument shape, stale thread handles, object-list cleanup, malformed graph links, jet constants, lighting ownership and older checkpoints.
Ruby Rebalanced C20 attaches defoliant and defoliant2 to the world-model
defoliant spawn marker, with particle-type flags 0x10041 and 0x10001.
Its fp_defoliant3 and fp_defoliant2 attachments instead name spawn fire,
which exists only on the first-person model, with flags 0x20041 and
0x20001. These are inspected map fields, not filename-based special cases.
The public particle-system format
identifies bits 16 and 17 as the first- and third-person drawing exclusions.
The inherited particle-system emitter queries only world-model markers, and its renderer does not apply these exclusions. Thus the first-person stream has no emission marker while the lower world-model stream appears in the player's view. In a hidden Windows reproduction, the original firing effect and projectile markers both resolved; that did not establish that the separate attached particle systems were working.
mcc_particles.c supplies the missing
MCC behavior. mcc_particle_system_markers uses the active local viewmodel's
marker for first-person-only types; a missing marker, remote or holstered
weapon, deleted handle or third-person camera does not fall back to the world
origin. mcc_particle_system_visible applies the exclusions for each viewer,
so another split-screen player can see the world stream without seeing the
owner's first-person stream. Types without view exclusions retain their
existing behavior. The two port: hooks in
particle_systems.c are necessary because
emission and drawing are private engine operations without registration
interfaces. Xbox and Custom Edition retain the native queries and drawing.
The adapter has no persistent state or allocations. Existing particle systems own their emitted particles and dispose them on map unload; orphaned first-person-only streams remain hidden. Weapon switching and camera changes are evaluated from current engine state. Projectile origins, damage, network messages and deterministic simulation are unchanged; the particle system uses the local visual random seed, so no network-version change is needed.
tools/test_mcc_particles.py exercises the actual adapter functions, including
marker failures, invalid attachments, view flags, split-screen ownership,
weapon deletion, view changes and MCC-to-legacy activation transitions.
Private before/after Windows captures of the same Ruby C20 fixture showed the
missing barrel stream before and a stream leaving the barrel after the fix.
The fixture changed only a starting profile's weapon to obtain the
flamethrower, and used temporary stationary firing input; neither change is
shipped. This is a bounded visual check, not full campaign completion.
The final release/portable Windows build passed, as did 149 focused regression checks (two skipped: an optional MCC map fixture and a POSIX-only socket harness). Both changed translation units also compiled to Android guest ELF and web Wasm objects with the generated target flags. Full Android and web builds were attempted but remain unverified: their generated Unix shell commands and the Android NDK wrapper cannot run unchanged on this Windows host, which has no WSL. These object checks do not replace full platform builds, multiplayer testing or visual checks on those platforms.
The final Windows binary also completed a single-process sequence from Ruby
C20 to Xbox a10, to Custom Edition deathisland, then back to Ruby C20,
with console responses after each load and a normal timed exit. This checks
bounded loading and activation transitions, not full legacy visual parity.