- SDL 3.4 holds an audio stream's lock through its callback, and the
game's data was put into the stream from the thread that runs the
game's callback, which then waited for that lock for ever: the first
callback never returned and nothing was heard. The data is now
gathered and put in by SDL's own thread once the game is done.
- debug.audio_log logs the level of the mixed sound.
- In VR a player's unit sees what its head points at within 15 degrees,
or what the weapon's laser points at, since the head only points
roughly where the eyes look (the training's flashing lights ask for
5 degrees).
- vr.log_performance also logs the unit's looking vector.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Scripts test where the player looks (unit_can_see_point, the unit's
looking vector), and the head only set it while the game let the player
turn; the training's "target each of the flashing lights" never passed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The training at the start of the campaign waits for the look input
(player_control.c's action tests, from facing_delta), which the head
never produced. The view's turning since the last test counts too, once
past a few degrees.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
With vr.aim_with = "controller" (the default), on foot:
- the unit's aiming vector comes from the right controller, while its
facing (the body, the view and the movement) keeps following the head;
- shots start at the muzzle of the weapon in the hand, kept inside the
level from the camera as before;
- the first-person weapon and hands are posed from the controller
(vr.weapon_forward/right/down place the model in the hand);
- the HUD's crosshair, which marks where the head looks, is left out, and
a laser runs from the weapon to what it aims at (vr.laser).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The Android port gets an OpenXR session in the host (Khronos loader, core
OpenXR plus XR_KHR_opengl_es_enable): on a headset the game keeps its
640x480 layout drawn at the eye images' resolution, renders the player's
view once per eye from the tracked eye poses through asymmetric frusta,
and shows the HUD and menus as a head-locked or room-fixed quad layer.
The head aims the player; the right stick turns; the Touch controllers
map onto the Xbox pad; rumble goes to the controllers. Frames without a
player view (menus, loading, cinematics) go onto a screen in the room.
A marker file, xr_test, runs a self-test of the session, layers, colour
path and controllers without game data.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Independently gate storage + K, OQ-4 P-a/P-b1, four static-local packets and comment-only disclosures. Preserve all 7641 exact owner rows, 71 valid parks and 1161 passing tests; code/data credit unchanged. G and game_engine admission remain held because current canonical loses populate_statistic_buffer. Existing collision static-local repair is not duplicated. No donor tree, held candidate, scorer or private asset imported.
Independently verified donors 8202ac13 and a448c595. Natural single-exit bitmap tail and first-party-correlated outer-arm width stores yield 714 meaningful / 736 padded bytes with zero inherited exact losses. Retire precisely their two freshly exact scheduling parks. No whole-object admission, helper/storage changes or new policy exception.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Independently rebuilt and reviewed donor 06645ef4. Uses the existing authenticated realcmp macro; its site spelling remains inferred and VN effect disclosed. 738 meaningful / 752 padded bytes, no exact losses. Retires only the freshly exact scheduler park.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Independently rebuilt and source-reviewed donor b659a777. Restores attested helper, clipping and color-call shapes; 743 meaningful / 752 padded bytes, 0 regressions. No new helpers or storage changes.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Independently verified donor 9f0b3af9413e6dc5c1be28786d22f0ea7df6c119. Restore the first-party-attested null-and-text-box-type invariant. The redundant check is genuine source evidence, not a fabricated allocator lever. Complete 608-byte section and 50 relocations match January; no new helper, owner, warning or exact regression.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Independently verified donor 9ed00bf758887d22ee67f9d1e8add23f317b2fc1. Restore the later first-party-attested live build_path flag, with January exact code and all 52 relocations. No new helper or storage owner. Whole-board batch sweep gains only the two reviewed functions and loses none; tests and warnings pass. The donor and all holds remain untouched.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
write_to_error_file opened and closed debug.txt for every line, which takes
milliseconds on Windows. A host logs thousands of lines when a hundred
machines join, load or leave at once, and while it writes them its own
client and every other machine wait. The native builds now keep the file
open and flush each line.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Found by running a 128-machine session with tools/system_link_bots.py:
- The listen backlog was 32 connections, so machines joining at once were
refused; it is now the machine limit.
- Socket buffers are at least 1 MB. A host's connection to a machine must
hold every update the machine has not acknowledged, up to 128 ticks of
3.9 KB with 128 players; a full buffer blocked the host for the write
timeout. The host's connection to its own client must also hold all it
sends in one frame.
- Each machine that finished loading logged a line for every machine
still loading, 8,000 lines as 128 machines load; it now logs a count.
- Removing a machine dumped the whole server state to the log; when many
machines left at once the host wrote dumps for minutes.
- Machines that had loaded heard nothing while the others loaded, and a
client drops a connection that is silent for 15 seconds, less than the
60 seconds the host waits for slow machines. The host now sends its
pregame keep-alive every 5 seconds while machines load; a client in game
ignores it.
All under HALO_LINUX; the MSVC build is unchanged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The Xbox game state (0x345000 bytes at 0x80061000) ends exactly where the
map-linked tag cache begins and has 948 bytes free, so a 128-player
session cannot even allocate its player datums. The native builds now
place a 16 MB game state (CPU 0xFC0000, GPU 0x40000) at 0x81A00000, above
the tag cache and below everything the Xbox memory window hands out
top-down, and grow the pools that scale with the number of players:
- objects: 2048 -> 8192 headers, 1 MB -> 8 MB pool; the garbage limits
keep January's proportions (5/10/20 % of the pool, 2.5/5/10 % of the
headers, 75/50/30 active garbage objects per 16 players)
- cluster partition reference lists 2048 -> 8192 (collideable and
noncollideable objects, lights); a full list drops objects out of
rendering, collision and sphere queries
- effects 256 -> 2048, effect locations 512 -> 4096
- particles 1024 -> 8192 (render_particles' visible list, filled without
a bound check, follows), particle systems 64 -> 256, their particles
512 -> 4096
- contrails 256 -> 1024, contrail points 1024 -> 8192
(MAXIMUM_CONTRAIL_POINTS stays the pool size for the same reason)
- lights 896 -> 4096, object looping sounds 1024 -> 4096
- cached object render states and rendered objects 256 -> 1024
- script object-list references 128 -> 1024, objects one explosion can
damage 64 -> 256
The values live in port/linux/include/halo_port_capacity.h, included by
halo_port_limits.h. With 128 player datums the CPU part holds 14,256,908
bytes (2,258,164 free). Saved games and cores grow to 16 MB. Every change
is under HALO_LINUX; the MSVC objects are unchanged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The 128-bit team mask is indexed by team; a player whose team is not
set (NONE) would read and write outside it, where the 32-bit mask only
shifted. Such a player now counts on its own.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Native builds only (#ifdef HALO_LINUX); the matching MSVC build keeps the
original text and stays byte-identical.
- ui_widget_game_data_input_functions.c: the local machine limit follows
HALO_PORT_MAXIMUM_NETWORK_MACHINES and the struct network_game copy holds
HALO_PORT_MAXIMUM_NETWORK_PLAYERS players; its layout is checked against
halo_port_limits.h. The pregame screen keeps its three remote machine
panels and shows the first three remote machines instead of asserting
(sizing its arrays by the machine limit read uninitialized widget
pointers). netgame_prejoin_players scans every player slot, and the
player count texts have room for three digits. network_machine_is_valid
widens the char index before comparing it with 128.
- ui_widget_event_handler_functions.c: the join/unjoin, team swap and
countdown handlers use the port's players offset and player count
instead of 0x226/0x242/0x243 and 16.
- hud.c: hud_draw_players sizes its teammate buffer by the port's player
limit and bounds the fill (more than 16 teammates overflowed the stack).
- motion_sensor.c: multiplayer tests the (horizontal) range before a unit
takes a blip slot, so distant units no longer crowd nearby ones out of
the 16 slots.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Native builds (HALO_LINUX) size the multiplayer game engine for
HALO_PORT_MAXIMUM_NETWORK_PLAYERS; the matching build keeps the January
text in #else branches and stays byte-identical.
- game_engine.c: MULTIPLAYER_MAXIMUM_PLAYERS follows the port limit; the
postgame statistic buffers hold an entry per player; global_goal has a
slot per player (slayer kill-in-order uses the absolute player index)
and the goal loops are bounded by the array instead of the address of
global_variant; game_engine_get_place uses a 128-bit team mask;
places past the 16th get code-generated English ordinals in the HUD
score messages, scoreboard and postgame instead of asserting or
clamping to "16th"; a free-for-all team is the player's absolute index.
- slayer, oddball, king, race: per-team and per-player score arrays follow
the port limit (oddball's ball arrays stay at 16); January size asserts
are kept for the matching build. Race reads the lap flags of the player
rather than of the player's team index.
- game_allegiance.c: a team past the 10-team table is not its own enemy,
like teams 0..9, so a free-for-all suicide no longer scores as a kill.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The Xbox game allows 16 players on 4 machines (4 split screen players
each). The native builds raise both limits to 128, keeping 4 players per
machine, and leave the byte-matching build unchanged: every change is
under HALO_LINUX (the MSVC objects compare identical).
- Limits: every local copy of the player and machine limits, and the
bare 4s and 16s that stood for them, follow halo_port_limits.h. The
player data array, the machine-to-player table (and its reset) and the
per-tick update arrays grow with them.
- Records: the copies of struct network_game agree on the larger layout
and check it against halo_port_limits.h; maximum_player_count becomes
a byte (128 does not fit a signed char); network_player_is_valid
checks the machine against the machine limit, not the split screen
one; a machine's input carries MAXIMUM_LOCAL_PLAYERS actions (16/4
would have become 128/128).
- Protocol: a message holds at most 4095 bytes (its header has a 12-bit
length), so the 13 KB game settings record is sent in 3.5 KB pieces
that clients reassemble; the per-tick update of 128 players (3,857
bytes) fits. Buffers and the packet codec's limits grow to match, and
the game search uses protocol version 2 so these builds and the Xbox
game never see each other's games.
- Connections: the host accepts a client connection per machine (the
split screen count stood in for it), FD_SETSIZE is 256, stream writes
send all of a message or drop a peer that stops reading instead of
corrupting the stream, and the input and update queues are larger.
- Host: lobby changes are sent at most every 250 ms instead of on every
change (a full lobby would otherwise send ~650 MB), in-game joins wait
in a queue instead of being dropped, the random name and colour
pickers stop looping forever once names or colours run out, machines
get 60 s to load a map, and the debug dump lists only the slots in
use (128 empty slots took seconds to log).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Independently reconcile W7 from 26684ca8: +1440 credited/padded bytes, 117 relocations, no new helpers or runtime owners. Retire only main_update_time's park in the same commit. Full build, stable board sweep with zero regressions, ownership/admission, warnings, fake scan and 1161 tests pass. No scorer or header changes.
Independently reconcile the +968-byte landing from 455dffad. All seven target-only view casts strip without changing runtime sections; both new helper copies match January and link with selected providers in both orders. Batch: +3 functions, +4208 canonical credited code bytes, +4224 padded, zero regressions; 1161 tests pass. No whole-object or data credit changes.
