A Prism or MultiMC instance keeps no jar of its own: the client sits in the
launcher root's shared libraries, two or three folders above `instances/`,
and the game is downloaded only once the instance is launched. Choosing
`%APPDATA%\PrismLauncher\instances` (or an instance's `minecraft`/`.minecraft`
folder) as the Minecraft folder failed Prepare when the jar was not there yet,
and the error only listed every launcher without saying what to do.
resolve now also looks in the launcher root above an `instances` folder, so a
folder deeper than the four walked above the chosen one still finds the
libraries. When nothing is found and the chosen folder is inside a launcher
Horizon knows, the error names it and says to launch the instance once so it
downloads the game.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
🤖 Agent: merged by Ludovic's AI agent after local checks on a6592eb1: workspace clippy clean; horizon-client/world/protocol tests pass; lan, chunk_stage, dedicated_server, block_entity_storage, chunk_generation PASS.
Settings gains a one-line Game arguments field, kept as `game_args` in
settings.json and appended to the client's command line after the
launcher's own, so a player can pass things like `--server-thread` or
`--render-distance 40`. Quotes group a word with spaces in it.
`horizon-launcher game-args [<line>]` shows or sets the line,
`play --arg <ARG>` passes one for a single run, and the MCP launch_client
tool takes an args array. The same splitter feeds all three.
Closes#716.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
tick_hoppers read the block under every plain container block entity
each tick (chests, barrels, shulker boxes, dispensers, droppers) to find
the hoppers. A hopper's block entity is the only five-slot one
(BlockEntity::for_block, and BlockEntity::id already names it the
hopper), so only those are looked up now; a position still needs a
hopper block to tick.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On a LAN world or a server, guests never got experience: orbs followed and
were taken only by the host's own player (none on a dedicated server), and
guests weren't sent orbs at all.
- Each orb follows the nearest living, non-spectator player within 8
blocks, the host or a guest (ExperienceOrb.followNearbyPlayer).
- A guest takes an orb as Player.aiStep does: one of those in its box grown
by 1, 0.5, 1, at random, at most every 2 ticks (takeXpDelay), repairing
with Mending first; the rest goes to the guest's experience (sent with
SetExperience as before), the level-up sound every fifth level.
TakeItemEntity goes to the players around, the pickup sound plays at the
orb.
- Orbs have entity ids and are tracked to guests (AddEntity, DATA_VALUE).
The client shows a server's orbs, moves them with the server's packets and
flies them to their collector.
tools/lan_e2e.py xp: three 7-point orbs near the guest: it sees three and
ends at level 2 (21 points); the host gets none.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A mob's push of a guest went to the guest as SetEntityMotion carrying the
server copy's velocity, which nothing damps: every tick of contact added
to it and replaced what the guest's client was doing. Vanilla pushes
players on their own client only (EntitySelector.pushableBy): the server
no longer sends those pushes, and a server client now pushes its player
away from every living entity it touches (Entity.push, team rules, no
spectators, bats or passengers of the same vehicle).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Minecarts were drawn every frame wherever they were: at render distance 32
every chest minecart of every loaded mineshaft went through the rail
lookups, display block and model, and the per-vertex terrain occlusion
test. Vanilla draws a cart only within 64 times its bounding box's mean
edge (about 57 blocks at entity distance 100%), measured from its current
position, and only when its interpolated box, grown by 0.5 and stretched
up by the display block's offset, is in the view
(EntityRenderer.shouldRender, AbstractMinecartRenderer
.getBoundingBoxForCulling). The cart the player rides always draws.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On a LAN world or a server, other entities' heads flickered between two
directions. The client wrote ClientboundRotateHeadPacket's head yaw into
the entity's yRot and the move packets' yRot into the body yaw, never moved
the head's previous yaw and pitch on, and never ran the body rotation, so
each frame interpolated the head from stale values.
As vanilla: move packets interpolate the position, yRot and xRot over three
ticks (LinearInterpolationHandler), RotateHead the head yaw over three
(lerpHeadTo), each tick keeps the previous head rotation for the frames, and
the body follows (a mob's BodyRotationControl, a player's walk direction
within 50 degrees of the look). AddEntity sets yRot and xRot and puts the
body and head at the packet's head yaw (recreateFromPacket).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On a LAN world or a server, a guest's clicks that went through the menu
engine (placing a carried stack, quick craft drags, double clicks, number
keys, Q) ran only on the guest's own copy and were never sent: the item
showed in the chest or furnace, the server still had it in the inventory,
and the next menu brought it back.
menu_ops now sends every click of the server's open menu as vanilla's
MultiPlayerGameMode.handleContainerInput does: the engine predicts it on
the client's copy, then a ContainerClick goes out with the slots it changed
and the carried stack after it (a drag is its three kinds of clicks). The
plain inventory and crafting table are predicted too, the Shift double click
sends each QUICK_MOVE, and a prediction no longer drops, crafts or makes maps
on the client (the server does).
tools/lan_e2e.py clicks: real mouse presses put a stack into a chest and a
furnace, drag planks over the crafting grid and craft; the server has each.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
At the end of each tick the game thread handed every player's held
packets to that player's writer thread, waking each one: a system call
per player, and on a busy machine often the rest of the core's time
slice to the woken writer. Now the batches go to one post thread in a
single send, and it wakes the writers. A packet sent to a player while
its batch is still with the post thread goes the same way, so each
player's packets keep their order.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
ChunkEncoder::body_in writes the LevelChunkWithLight body that
Clientbound::encode would give, into one buffer sized up front: the
cached section bytes and light layers are copied once, uniform light
layers are filled in place, and the heightmaps are shared rather than
cloned. Before, each chunk sent built a packet (growing its buffer,
cloning every 2048-byte layer), then encode copied all of it again.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A server client sent UseItem and never started the use itself, so food
showed no eating animation or crumbs, and holding right click sent a new
UseItem every 4 ticks. Like MultiPlayerGameMode.useItem, the client now
starts eating (Consumable.startConsuming), counts the use down for the
animation and its particles, and starts no other use until it ends; the
server still eats the item. Looking at another player no longer stops
the item from being used (Player.interactOn passes).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The bed's sleeping state, timer and respawn point were the host's fields,
so a guest clicking a bed put the host to sleep and moved the host's
spawn. as_guest now swaps them with the guest's own; the guest gets its
sleeping pose and bed (entity data 14), wakes on STOP_SLEEPING with the
WAKE_UP animation, and the night skips only once enough players sleep
(players_sleeping_percentage). Guests respawn at their own bed, else the
world spawn. Server clients lie in the bed from the synced position.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
wgpu replays an indirect multi-draw on Metal as one draw call per entry, so
every frame encoded a draw per visible face range and translucent section
(9,300 at render distance 32). Where multi-draw is emulated (Metal) and a
frame has at least 4,096 section draws, a compute pass now copies the
frame's section draws into one index list, in draw order, and each run of
sections in the same arena page is one draw call: 9,309 draw calls become
about 750 at RD32. Smaller frames keep the per-section draws, where the
list's GPU cost (about 0.4 ms on an M4 Pro at RD16) outweighs the CPU saved.
The picture is unchanged by construction: the same triangles from the same
vertices in the same order through the same shader code. Only where a
vertex finds its section's origin changes, from the instance attribute to
a table: a section's vertices fill whole 256-vertex blocks of its page, each
block names the section, and the section's camera-relative origin is
computed on the CPU exactly as before.
Vulkan keeps the native multi-draw. HORIZON_FLAT_DRAWS=1 draws every frame
flat (any backend that supports it), 0 never; the control command
`section-draws flat|indirect` switches in a running game for A/B checks.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Apple GPUs time only pass boundaries (no TIMESTAMP_QUERY_INSIDE_ENCODERS),
so the GPU timer was off on every Mac and benchmarks reported no GPU time.
Where only pass boundaries can be timed, the frame is now bracketed by two
empty compute passes that write the timestamps.
HORIZON_SPIKES also names the renderer's parts (occlusion, visibility,
encode, submit), and the status reply counts the frame's section draws and
the draw calls that submit them.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
TickCtx gained `collision` here; main's two newer initializers
(lan_actions respawn, server_travel's server_ctx) now pass it too, as
every other one does.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
DedicatedServerProperties.WorldDimensionData: a world that doesn't exist
yet gets level-type's preset (flat or normal; an unknown name warns and
falls back to minecraft:normal), a flat world's generator-settings
(FlatLevelGeneratorSettings: layers, biome, lakes, features; a layer that
doesn't parse is logged and left out, and settings without layers use the
preset's classic ones) and generate-structures, written to
world_gen_settings.dat before the world opens, with vanilla's log lines.
Horizon ignored all three and always made a normal world.
New harness server_world_gen compares world_gen_settings.dat and the lines
logged with vanilla's for five server.properties.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On a server, single player's server thread included, the inventory
had no recipe book: the window ignored the recipe book packets, and
the server ignored a guest's ServerboundPlaceRecipePacket.
- horizon-protocol decodes the recipe book's packets and the recipe
displays they carry: RecipeBookAdd / Remove / Settings,
PlaceGhostRecipe and the serverbound PlaceRecipe. Every 26.3
`recipe_display` and `slot_display` type is decoded (shaped,
shapeless, furnace, stonecutter and smithing displays; empty,
any_fuel, with_any_potion, only_with_component, item, item_stack,
tag, dyed, smithing_trim, with_remainder and composite slots).
- The remote client keeps the book the server sends (ClientRecipeBook:
added, highlighted, removed, replaced), shows the unlock toast,
applies the open and filter settings, and counts the menu the
server last sent for the craftable filter. Clicking a recipe sends
PlaceRecipe; a ghost recipe from the server fades in.
- The server handles a guest's PlaceRecipe in the inventory grid and
the crafting table (ServerPlaceRecipe on the menu engine, for known
recipes only) and answers with the slots, or a ghost recipe when the
items are missing.
- The screen state reports the recipe book's buttons.
lan_e2e.py gains a `recipes` check: the guest gets oak logs, opens the
book, clicks the planks recipe, and a log lands in the grid.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
/give, /clear, /gamemode, /experience, /advancement, /playsound and the
whisper-to-yourself lines printed the host's placeholder name for the
acting player. They now use the acting player's name (a guest's own while
their command runs), as target_name and the scoreboard do.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
While a guest's command or action runs, the score holder, team, display
name and death and kill criteria of the acting player use the guest's own
name (ScoreHolder.getScoreboardName), as on vanilla's server.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
CommandSourceStack.broadcastToAdmins: on a dedicated server, a guest's
command success (sendSuccess with broadcast) is logged on the console as
"[Name: message]" when log_admin_commands is on, and sent gray and italic
to every other operator when send_command_feedback is on. The queries and
lists vanilla sends with broadcast false (commands/admin.rs) stay with the
player who asked. Lines are queued while the guest acts and sent once the
command returns.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
ditto without --norsrc --noextattr --noqtn stores an AppleDouble ._ entry
beside every file that has extended attributes, so the macOS release zip
held hundreds of them (horizon-macos-arm64/._horizon-ctl, tools/._*.py).
Package it as packaging/macos/package.sh already does, and fail the job if
any ._ or __MACOSX entry is left.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The window dropped ClientboundCommandsPacket ("argument nodes are not
decoded"), so on a server, single player's server thread included,
the chat was a bare input line without completion, colouring or usage.
- horizon-protocol decodes argument nodes: the 26.3
`command_argument_type` ids and every parser's properties
(ArgumentTypeInfo.deserializeFromNetwork), plus the custom
suggestion provider.
- command::network turns the tree into a Dispatcher. A node at a path
the client's vanilla tree also has takes that node's argument type
and suggestion provider; any other node takes the type its parser
and properties describe.
- On a server the chat is ChatScreen over that tree, so Tab completes,
arguments are coloured, usage and errors show, and Enter sends the
command to the server. Player-name suggestions come from the
server's player list. The old bare input line is gone.
- The screen state reports the chat input (`chat_input`).
lan_e2e.py gains a `commands` check: the guest completes `/gamem` to
`/gamemode` and `/gamemode cr` to `/gamemode creative` with Tab, and
the command runs.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On a server (the integrated server thread and the dedicated server)
the host has no player of its own, so effects that only touched the
host's player reached nobody; on a LAN world they reached only the
host. Beacons, the warden's and shriekers' darkness, the elder
guardian's mining fatigue, splash and lingering potions' splash and
the raid victory's Hero of the Village now run for each player in
the level, guests through `as_guest`.
The elder guardian's curse sends the guest the GUARDIAN_ELDER_EFFECT
game event, which the remote client now shows (the apparition and
the curse sound).
lan_e2e.py gains an `effects` check: a speed beacon next to both
players must give both of them speed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
With an explicit Present Mode (Mailbox, Immediate), the VSync option did
nothing: the setting replaced vanilla's choice even with VSync on, so a
window kept running uncapped. Vanilla's VSync means Fifo, in a window and in
fullscreen alike. Now VSync on always presents with Fifo, and the Present
Mode setting chooses only while VSync is off (Auto keeps vanilla's choice:
Immediate, else Mailbox, else Fifo). The choice is one tested function,
window::chosen_present_mode.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The LAN chunk encoder's section cache (#623) and dimension range (#668)
are kept; a cached section's wire bytes use the registry's palette width,
set once per process before any encoder exists, so the cache stays keyed
on the section alone. The sculk scan's palette check takes the u32 state.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
LAUNCHER_PATHS and launcher.yml's push paths now list horizon-bench,
horizon-friends, horizon-mods and horizon-port-pack too, the launcher's
path packages per cargo metadata. A change there (like the horizon-mods
dependency that left launcher/Cargo.lock stale) then builds and releases
the launcher instead of going unnoticed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>