encode_in built the light layers twice (encode filled them for every
section, then encode_in replaced them with the ones that exist around the
column). On the ThinkPad at 25 walking bots light_data was 8 % of the server
thread. The light is now built once, and a section's packed DataLayers stay in
the section cache while the section is unchanged (relighting moves it to a new
address, as an edit does). Uniform light is filled directly, not kept.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The server holds one level at a time, as the in-frame game does. While one
player is online (single player on the server thread, or a world with one
player in it), a Nether or End portal swaps the server's level the
in-frame way (switch_level, split out of enter_dimension) and the player
is moved as ServerPlayer.teleport moves it into another level: a Respawn
packet keeping all data, the difficulty, permission level, teleport,
abilities, level info, inventory, effects and the portal travel sound,
then a teleport to the exit once the destination has loaded (the Nether
portal found or built, the End platform, the Overworld's spawn column).
Respawning away from the Overworld takes the level back there first.
What the hub sends follows the level:
- Chunks carry the level's sections only (y 0 to 255 in the Nether and the
End), without sky light where the dimension has none, and heightmaps
from the level's floor. Until now every level went out with the
Overworld's 24 sections, which a client in the Nether or the End reads
64 blocks off.
- The dimension type follows the level the hub names; the default spawn
position is the Overworld's.
- A level switch keeps the block change log (an open hub kept none after
a portal) and the sculk watch list.
Worlds whose player is in the Nether or the End now open on the server
thread too.
The network client maps the End to the End (it drew it as the Overworld)
and shows the death screen on its own PlayerCombatKill, as
ClientPacketListener.handlePlayerCombatKill does, whatever health came
last.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
ClientboundUpdateAdvancementsPacket and ClientboundAwardStatsPacket are
new in the protocol crate, and the window applies them as vanilla's client
does:
- ClientAdvancements.update: a reset replaces the tree, added advancements
join it with their place on the tab (DisplayInfo x, y), removed ones go,
each changed one takes the progress sent, and one that is done in a
non-reset update with show set gets its toast. The advancements screen
lays a server's tree out where the server placed it and shows everything
it sent.
- handleAwardStats: the counters the server sends, by registry name.
Opening the statistics screen asks for them (StatsScreen.init's
REQUEST_STATS).
Joining and leaving a server start from empty advancements and statistics.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The launcher's "Import modpack" needs the pipeline as a library and a way to
get the jars a pack names without redistributing anything.
- The steps move into the library (pipeline.rs) with a line callback, so the
command line and the launcher run the same code; main.rs is a thin CLI.
- fetch: the jars of the portable mods (content, data tier) into
<work>/jars/, the player's own downloads: copied from a folder they have
(by SHA-1, or a CurseForge app instance's minecraftinstance.json), else
from the pack's own link (.mrpack hosts only) or the same file on
Modrinth's public CDN found by SHA-1, kept only when the hash matches.
What only CurseForge has is listed as needing a CurseForge API key.
<work>/fetch.json records each file.
- port: every step after the import for the portable mods (fetch, the
inventory again with the jars read, carry, report).
- A CurseForge zip whose overrides hold Crash Assistant's modlist.json (All
the Mods 10 does) takes its jar names, mod ids and SHA-1s instead of bare
project ids, so Modrinth answers for most files.
- inventory goes on offline when Modrinth cannot be reached.
All the Mods 10 8.3's CurseForge zip: 496 files named; of the 54 data-tier
content mods 42 download from Modrinth's CDN (84 MB) and 12 need the key or
the player's instance; 42 carried over (partial: the harness is a dev step).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Single player on its server thread, LAN guests and dedicated server players
are network players, and the server gave them none of these:
- PlayerAdvancements: each player's progress loads from and saves to
players/advancements/<uuid>.json (an integrated server's owner keeps
single player's file). The game's triggers, awards and the advancement
commands work on the player the game acts for (as_guest swaps the
progress in), every tick runs the tick, location and inventory triggers,
and flushDirty sends ClientboundUpdateAdvancementsPacket with what became
visible or hidden and the progress that changed. A player who has been
here gets their saved advancements in the first packet; a new one gets
the same first tick as before. Announcements go to everyone
(PlayerList.broadcastSystemMessage).
- ServerStatsCounter: per-tick and movement statistics are counted for each
player, saved to players/stats/<uuid>.json, follow the scoreboard
criteria under the player's name, and go out in
ClientboundAwardStatsPacket when the client asks (REQUEST_STATS), all of
them the first time.
- ServerRecipeBook: the player file's recipeBook is kept, sent on joining
(settings and every known recipe), and recipes unlocked later go out in
ClientboundRecipeBookAddPacket.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Main's startup now falls back to vanilla resources when packs fail; the
behaviours snapshot folder is set just before.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
With single player on its server thread, the window is the server's client
and dropped several packets the in-frame game never needed:
- ClientboundBlockEntityDataPacket and the block entities of chunk packets:
the block entity of that type loads the tag (signs, spawners), as
handleBlockEntityData and LevelChunk.replaceWithPacketData do.
- ClientboundChangeDifficultyPacket: the level data's difficulty and lock.
- ClientboundSetDefaultSpawnPositionPacket: the respawn data spawn
compasses point at.
- ClientboundSetChunkCacheCenterPacket: ClientChunkCache's view centre;
columns outside the storage (the server's radius + 3) are ignored or
dropped, as ClientChunkCache.Storage does.
- ClientboundAnimatePacket: wake up, and the critical and magic critical
hit emitters.
- ClientboundTickingStatePacket / ClientboundTickingStepPacket (new in the
protocol crate): the level's TickRateManager. A frozen level holds its
time and non-player entities, and the server's rate only ever slows the
client timer down (Minecraft.getTickTargetMillis).
- ClientboundServerDataPacket: the server list entry keeps a valid icon
(ServerList.saveSingleServer); single player has no entry.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Path searches (vanilla's PathFinder with WalkNodeEvaluator) were 14 % of
the world tick with 80 villagers. Two costs vanilla doesn't have:
- the node index and the per-query path type and collision caches used the
standard SipHash; vanilla keys them by packed position in fastutil maps.
They use the Fx hasher now (nothing iterates them, so no order changes);
- a position's static path type (its block, the one below and up to 24
neighbours, `getPathTypeStatic`) was worked out again for every mob box
that covered it. Vanilla caches the block part level-wide
(`PathTypeCache`); the finder now remembers each position's type for the
query, during which the world doesn't change.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
When chunks arrive, the sculk index looks through them for sensors,
shriekers and catalysts. It unpacked and tested all 4,096 blocks of every
section that wasn't uniform: 10 to 18 ms in a tick after a world loaded,
more over a larger render distance (#489).
A section whose palette holds no sculk state has no sculk block, so it is
passed over without reading its blocks; the others are scanned as before,
and the same blocks are found.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every tick, each item and mob that can use a portal sweeps the blocks its
box passed through since the last tick, looking for a nether portal block
(`Entity.checkInsideBlocks` reaching `NetherPortalBlock.entityInside`).
Each sweep allocated a visited set and read every block of the path.
Every block a sweep visits lies in the box covering the entity's box at
both ends. When no section that box touches has a nether portal state in
its palette, no visited block is a portal: the sweep is skipped. Sections
are checked once per tick, and a box over more than 64 sections (an
entity teleported far) is swept as before.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Block collision scans (vanilla's BlockCollisions) are most of every mob's
move, and moves were the largest share of the world tick with 600 mobs.
Per cell and per hit, the scan did work vanilla's JIT makes cheap:
- the cursor divided its index by the box width and height for every cell;
it now counts x, then y, then z, as Cursor3D does (same cells, same order,
same budget);
- the unit cube test cloned the shared unit cube to compare identities
(`VoxelShape::is_block` compares with it in place), and built a
normalised box to test it against the entity box (`intersects_corners`);
- every non-empty block looked its state up in the contextual rule map
(scaffolding, liquids, powder snow); a flag in the scan table now says
which states have one;
- a moved shape decomposed its occupancy into boxes again; the moved
shape's boxes are its own boxes moved, the same values.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A loaded world had none of its structure starts in the generator's cache.
The first time natural spawning (or anything else) asked which structures
hold a position in a chunk referencing a village, the game thread built the
village start: 60 to 120 ms in one tick, once right after the world opened
and again a few ticks later for the next start (#489).
Vanilla reads the starts with the chunk. The streaming worker that loads a
saved chunk now builds the starts it references into the same cache, so the
game thread finds them there. The starts are the same: the same function
builds them from the same seed and chunk, only earlier and on a worker.
The cache now keeps the first starts built for a chunk when two threads
build them at once, so every user shares one start and its pieces'
placement state, as vanilla's single StructureStart does.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
lan_actions.rs: clear the old body's potions (main), then respawn with
the tick context (this branch). hub.rs: keep main's effect and chunk
tracking reset before this branch's vanilla respawn sequence.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The bots acknowledge chunk batches with ChunkBatchSizeCalculator's
desired chunks per tick, from how long each batch takes to arrive,
instead of a fixed 25. A bot moves only while it holds the chunk it
stands in, as vanilla's client stops ticking its player in a chunk it
hasn't received, so no bot outruns a server's chunk sending. Each bot
keeps the chunks it holds, so the report separates chunks that entered
its view from chunks sent again while it still held them, and counts
the moves the server refused and the ticks it waited for its chunk.
server_bench.py runs one pass per behaviour (walk, explore), spawns
every bot on the world spawn itself (respawn_radius 0) so both servers
see the same paths, can run the bots on another machine (--bots-via,
--bots-bin, --connect) and the servers under nice, and reports new,
dropped and re-sent chunks per second, pull-backs and the server's
"moved too quickly" lines.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
PlayerChunkSender: one unacknowledged batch until the client's first
acknowledgement and ten after it, batches capped at the client's
desired chunks per tick (not twice that), and the quota reset to one
chunk whenever every batch is acknowledged.
ServerGamePacketListenerImpl.handleMovePlayer: a move further from
where the tick began (firstGood) than 100 blocks squared per move
packet (300 while gliding; the count falls back to 1 past 5 packets)
logs "<name> moved too quickly!" and pulls the player back, as the
player_movement_check and elytra_movement_check game rules allow.
NaN coordinates or non-finite angles and two position moves in one
client tick disconnect with invalid_player_movement, positions are
clamped to the world's limits, an unanswered teleport is sent again
after 20 ticks, and accepting a teleport runs the move it carries.
The move is then replayed against the blocks: a survival or adventure
player who ends more than 0.25 blocks short of the target (horizontally;
vanilla drops the vertical part) logs "<name> moved wrongly!" and is
sent back unless they were already stuck, and any move into a block
the old box did not touch (isEntityCollidingWithAnythingNew) is sent
back silently. Spectators and sleepers skip both. Angles wrap as
Mth.wrapDegrees does.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Loading the eight carried-over mods in the game (not only the probe) showed
two limits real packs reach. Block textures past 2048 layers are another PR;
this one handles block states and measures a pack.
- Chunk sections store a block state in 16 bits. Vanilla 26.3 has 35,723
states; Macaw's four mods add 36,154, the eight 41,389. Past 65,536 ids
wrapped onto other blocks (a trapdoor became a hanging sign).
mod_content::build now refuses a set of mods past MAX_STATES and names the
states per mod; the game then starts without content mods, as for any
refused content.
- tools/mod_port_harness.py probes each mod on its own against vanilla, as a
player adding it would load it.
- tools/perf_bench.py --game neoforge: Minecraft 1.21.1 on NeoForge 21.1.259
with --mod-jars and --deps, driven by a dev-only NeoForge port of the bench
mod (mods/horizon/src/neoforge-bench); --port-work loads a work folder's
carried-over mods into Horizon. tools/neoforge_oracle.py installs the
client once under .local/neoforge-oracle (the installer, then the vanilla
libraries it inherits, sha1-checked) and builds the driver. A NeoForge
start that crashes before the driver loads (FML reading fml.toml while
creating it) is retried once.
Measured (docs/modpacks.md): six ported mods in Horizon against the same
mods on NeoForge, Mac mini M4 Pro, 2 games per row on a loaded machine. The
world is ready 3.1x sooner at 8 and 16 chunks, the flights run 1.7x and
3.6x the frames, and Horizon's RSS is not lower (+1.1 GB with the mods).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every packet sent to a guest woke its writer thread, and at 25 walking bots
those wake-ups (mpsc notify, semaphore_signal) were about a quarter of the
server thread's tick. While tick_lan runs, packets for each guest are held
and handed over in one Out::Packets at the end; a send outside a tick, or a
disconnect, first hands over what is held, so the bytes and their order are
unchanged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
options_ui.rs: #585 put Mods... in the telemetry slot; keep it and put
Horizon Extras... in the credits slot as this branch intended.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>