🤖 Agent: merged. Verify passes. Proof: the B5 integration of these eight heads (parity --changed 102/102, lan_e2e 46–47/48 with only order-dependent flakes), and the conflict resolution in tools/lan_e2e.py checked def by def against each branch.
🤖 Agent: merged. Verify passes; local parity --changed origin/main passes (101 harnesses; #1159's one online_mode diff reran clean and passes on main). Screenshots and tick-by-tick results in the body.
🤖 Agent: merged. Verify passes; local parity --changed origin/main passes (101 harnesses; #1159's one online_mode diff reran clean and passes on main). Screenshots and tick-by-tick results in the body.
On single player's server thread the broken log's drop and its pickup
both come from the server, a few ticks after `break` answers: the
pickup could land before the scenario looked for the drop, which it
then never found (StopIteration). Step 3 now waits up to 20 ticks for
the logs in the inventory or the drop to walk to.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Step 2 clones a stack in the creative tab and closes the screen. The
clone lived only on the client: ItemPickerMenu's carried stack is the
inventoryMenu's, and AbstractContainerMenu.removed clears the carried
stack only for a ServerPlayer, so vanilla's client still holds it when
the survival inventory opens. With a stack in hand the middle button's
release sends CLONE (AbstractContainerScreen.mouseReleased); the server
finds the carried stack it was told about wrong and sends the empty one
(broadcastChanges). On single player's server thread that answer takes
a round trip, as in vanilla, so step 3 now waits up to 20 ticks for it.
The in-frame world puts the clone away when the menu closes.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
From b9f3821f (fix/server-thread-default): the host window draws what
it was sent on the server thread, and agent_control_e2e waits two ticks
where the server answers a click.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On a client of a server (single player's server thread, a LAN guest) the
placed block comes with the server's answer: `place` waits up to a second
for it before reporting no change. agent_control_e2e tries the next free
spot when the tree's trunk above the broken log hides a spot's faces.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 9821bb7ef54112200c720c2ca91f10187b4ea693)
- The command harness (HORIZON_COMMAND_SCRIPT) drives the world itself,
without the event loop, so it does not start the server thread.
- `status` lists the minecarts a client of a server was sent.
- save_roundtrip: single player's server thread finishes the chunks its
player tracks, as vanilla's integrated server does, including some that
vanilla's server (view distance 4) left before their terrain or light.
Those had no blocks, light or heightmaps to compare yet.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 2818c89f242fd0856c098ceeb7c809c776120240)
Single player's world now runs on the integrated server thread unless
asked otherwise, as vanilla's does, so a world tick no longer holds up
a frame. `--no-server-thread` or `HORIZON_SERVER_THREAD=0` keeps the
world in the frame as an escape hatch; `--server-thread` stays.
lan_e2e.py sets the host's mode explicitly either way.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 4ff23b686d44249c9c8d6dc9d0f9d3c12ed6afcb)
The guest came home into its Nether portal's frame, with an obsidian
ceiling three blocks up, and the host onto the End portal it had set at
spawn; both stayed there for the rest of the run. Under that ceiling a
double jump rises about 1.2 blocks at most, and whether the flight check
saw it depended on timing: `flight` failed in full --server-thread runs
(portals runs only there) and passed alone. The check now clears the
frame and the End portal in the overworld, and puts the guest back where
it started, also when it fails.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A player who joined already in creative could not fly: the remote
client kept only instabuild and the flying speed of
ClientboundPlayerAbilitiesPacket, and the motion step clears flying for
a player that may not fly. The packet also comes before the client has
a player (it is made at the first teleport). Single player creative on
its server thread could not fly at all; a LAN guest only after a game
mode change.
- The remote client keeps the last abilities and applies flying, may
fly, invulnerable and the flying speed to the player, also when the
player is made (ClientPacketListener.handlePlayerAbilities).
- When its flight turns on or off (double jump, spectator, landing) it
sends ServerboundPlayerAbilitiesPacket (LocalPlayer.onUpdateAbilities).
- The hub keeps it as the guest's flying when the guest may fly
(handlePlayerAbilities), so the save has it, and a game mode change
sets it as GameType.updatePlayerAbilities does.
- lan_e2e `flight`: the guest, and on the server thread the host's
window, fly in creative, stay up, and stop in survival.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Vanilla plays a block use's sound with `level.playSound(player, ...)`: the
player who clicked hears it from their own client's use, and the server
sends it to everyone else. Horizon's guest waited for the server's sound,
one round trip after its predicted door had already opened.
The guest now plays the sounds of the use it predicts (doors, trapdoors,
fence gates, levers, buttons), and the server sends the sounds of such a
use to the other players only. The control socket's `status` counts the
positional sounds each game played (`heard`).
lan_e2e `predict`: with the host frozen, the guest already hears its door;
once the server answers, the guest and the host have each heard it once.
Fixes#869
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A client of a server sent the bow's use but never started using the item
itself, so letting go of the button sent no RELEASE_USE_ITEM: the server
kept the guest drawing and never shot. BowItem.use runs on the client too
(startUsingItem, with an arrow or in creative), and Minecraft.handleKeybinds
releases the item in use once the button is up.
The guest now draws on its own side as well (held until the button lets go
or another slot is picked), so the server shoots when it lets go.
lan_e2e: `arrows` passes both ways now (the guest's arrow hurts the host);
the `pvp` and `arrows` checks allow the victim natural regeneration while
pvp is off (it healed 19.3 -> 20 and failed the exact check).
Fixes#484
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Vanilla's MultiPlayerGameMode.useItemOn runs the use on the client's own
level inside startPrediction, records each block it changes under the
packet's sequence in BlockStatePredictionHandler, and keeps them until
ClientboundBlockChangedAckPacket settles them (a use the server refused
goes back). A Horizon guest only sent the use: its door opened one round
trip later.
The guest already ran the use on a dry copy of its level to know whether
the click ends there; the blocks that use changes are now kept on its
level as predictions under the use's sequence, as the break prediction
does, when they are all hand-operated blocks: a wooden or copper door,
trapdoor or fence gate, a lever or a button (an iron door has no hand use
and changes nothing). The sound still comes from the server.
lan_e2e `predict`: with the host process frozen, the oak door the guest
clicks is already open on the guest's side (both halves), stays open on
both sides once the server answers, and an iron door stays shut.
Fixes#869
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A remote player's projectiles never hit other players: a player's shots
only looked for mobs and the host, a guest's flew as if the host had shot
it (so it could not hit the host until it left the host's box), and a hit
on a guest from another guest ran as the shooter, who has no hub to reach
the victim. No bow PvP on a server or between LAN players.
A player's arrows, snowballs and eggs now meet every player, a guest's
flying from that guest (Projectile.getOwner). A hit on another player runs
as the victim's hurt, refused when the pvp game rule is off or the teams
are allies without friendly fire (ServerPlayer.canHarmPlayer), which turns
the arrow back as a raised shield does (AbstractArrow.onHitEntity).
Pearls, potions and wind charges fly past players as before.
lan_e2e `arrows`: the guest shoots the host and the host the guest with a
bow, both hurt; with pvp off, no harm.
Part of #484
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
LivingEntity.die credits the kill to lastHurtByPlayer: the killed
statistic, the mob_kills custom statistic, the kill score criteria and the
player_killed_entity trigger belong to that player. Horizon kept only
whether a player had hurt the mob, and the death ran as the host, so a LAN
or server guest's kills counted in the host's statistics and advancements.
The mobs a player hurt now remember which player (the acting guest's
connection, or the host), and the killer's side of the death runs as that
guest.
lan_e2e `kills`: a pig the guest kills shows in the guest's
minecraft.killed:minecraft.pig score, not the host's.
Part of #484
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The hub's players are server players too, and in vanilla the armour they
wear counts against every hit (LivingEntity.collectEquipmentChanges puts
each piece's attribute modifiers on the player, getDamageAfterArmorAbsorb
reads them). Horizon only put them on the host: a guest who put armour on
in its inventory menu (the hub moves it), joined wearing it, respawned with
it kept or came through a portal (a new body each time) was hurt as if it
wore nothing. Iron armour, 15 points, should take a 10-damage blow down to
6; a guest took the full 10.
Each guest now keeps its own list of applied equipment modifiers, swapped
in with the rest of its state for its turn, and its armour and main hand
are put on its attributes whenever they differ from what they were put on
for (a new body starts with none).
lan_e2e `worn`: the guest shift-clicks iron armour on in its inventory and
takes 10 mob-attack damage: 6 with it, 10 without (failed before: 10 and 10).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit e0549f88cebfe20625f66dd04348252cef6cea6c)
ServerExplosion.hurtEntities takes every entity in range, players
included, but only the host player was hurt and pushed: LAN guests stood
in a blast untouched. The player's part is now its own function, run for
the host and then for each guest in the level, swapped in as the player.
It also follows Player.hurtServer more closely for everyone: the damage
goes through a raised shield (an explosion is blocked like any attack
from where the blast is, the shield takes wear), the push is reduced by
explosion knockback resistance, and a spectator or a creative player
flying is not pushed.
tools/lan_e2e.py gains a `blast` check: primed TNT five blocks from a
survival guest hurts it (20 -> 4.6) and pushes it away; facing it behind
a raised shield, the guest takes nothing. Before this change the guest
took no damage and no push.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 0782a598fee9b6de75d367eb11734267df3c7fd4)
PiglinAi.throwItemsTowardPlayer aims at NEAREST_VISIBLE_PLAYER: the
nearest living, non-spectator player within 16 blocks. Only the host was
considered, so a LAN guest who bartered saw the loot fly to the host.
lan_e2e's new barter check: the guest, in gold boots, drops a gold ingot
to a piglin in a glass corridor with the host on the far side; the
piglin stays calm and the barter reaches the guest. It fails on the old
build (the loot lands on the host's side).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 896f12f7321852bf8e654d466c51692db59882c9)
Player.attack on a #minecraft:redirectable_projectile (a ghast's fireball,
a wind charge) deflects it with ProjectileDeflection.AIM_DEFLECT: its
movement becomes the attacker's unit view vector and the attacker its
owner, with the no-damage sound. The crosshair finds these projectiles a
block round their box (AbstractHurtingProjectile.getPickRadius), a remote
client sends the attack for them, and the host turns one a guest strikes
along that guest's view. A fireball a player turned back kills the ghast
it hits (Ghast.isReflectedFireball: no fire immunity, 1000 damage).
lan_e2e.py --check deflect: the host strikes a caged ghast's fireball and
the ghast dies; before, the fireball hit the host.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 6ba02f5205ba0f6ca2e68d4b0dfa53c86b768d82)
SmallFireball.onHitBlock places fire with Level.setBlockAndUpdate and
BaseFireBlock.getState (soul fire on soul soil and soul sand), and a mob's
fireball only when mobGriefing is on. Horizon wrote a plain fire state
straight into the chunk: no block updates and no scheduled fire tick, so
the fire never aged and never went out, even on stone or nether bricks
where vanilla's goes out within about half a minute (FireBlock.tick). Every
blaze fireball that missed left a fire that stayed for good: fortress
floors round a spawner filled with fire that kept everyone near it burning.
The fire is now the level's fire state for the spot, set with updates
(the fire's tick is scheduled on place), and only with mobGriefing when a
mob shot it.
lan_e2e `fireball`: a dispenser shoots a fire charge onto stone; both
players see the fire and it goes out by itself (failed before: still burning
after 1200 ticks; now out after about 480).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 5b7235c24bedf878a15f86322d386337b9ed8e95)
🤖 Agent: merged. Verify passes. B5's local integration of all its PRs on main: parity --changed 102/102, plus lan_e2e (flakes listed in FEATURES.md LATER 4l).
🤖 Agent: merged. Verify passes. B5's local integration of all its PRs on main: parity --changed 102/102, plus lan_e2e (flakes listed in FEATURES.md LATER 4l).
🤖 Agent: merged. Verify passes. B5's local integration of all its PRs on main: parity --changed 102/102, plus lan_e2e (flakes listed in FEATURES.md LATER 4l).
🤖 Agent: merged. Verify passes. B5's local integration of all its PRs on main: parity --changed 102/102 (the explosion-dependent 22 rerun after rebasing onto #1101), and lan_e2e passes except checks that fail only after earlier checks and pass alone (in FEATURES.md LATER 4l).
🤖 Agent: merged. Verify passes. B5's local integration of all its PRs on main: parity --changed 102/102 (the explosion-dependent 22 rerun after rebasing onto #1101), and lan_e2e passes except checks that fail only after earlier checks and pass alone (in FEATURES.md LATER 4l).
Three differences from vanilla's Axolotl kept the brain from matching:
- The constructor's setPathfindingMalus(WATER, 0) was missing, so every
swim target in water failed DefaultRandomPos's malus check and idle
axolotls never picked a walk target.
- Axolotl.getWalkTargetValue returns 0 everywhere; Horizon used Animal's
light-based value, which picked the brightest candidate instead of the
first.
- Axolotl.playAttackSound (entity.axolotl.attack at pitch 1) never played.
The mob AI harness gets #64's two scenarios, in a pool sunk into the ground
so no water flows out of it: hunting a cod, and playing dead after repeated
hits. Both now match vanilla on every tick (393/393 mob-ticks, was 26).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On a server or a world open to LAN, a player saw only their own crack.
The server sent each new stage to the others
(ClientboundBlockDestruction), but a client of a server ignored the
packet, and the host of a LAN world neither drew its guests' cracks nor
sent its own to them.
Vanilla keeps the cracks per breaker (ClientLevel.destroyBlockProgress:
a progress outside 0..9 removes it, 400 ticks without news drops it) and
draws, within 32 blocks, the furthest one on each block
(LevelExtractor.extractBlockDestroyAnimation). Horizon now does the
same: a client of a server takes the packet, a LAN host records its
guests' stages and sends its own (each new stage, then -1 when it
stops), and every crack is drawn with its own stage. A guest's crack
also goes when the block it digs is gone before its STOP_DESTROY_BLOCK
(its own tick broke it), as ServerPlayerGameMode.tick clears it on air:
the others kept its last stage for 400 ticks. Each crack vertex carries
its stage sprite's atlas origin in its light bytes (the crumbling pass
is unlit); the shader keeps the shared sprite size.
lan_e2e `cracks`: each side watches the block the other mines and sees
its crack grow; no crack is left once the blocks break. The screenshots
from both sides show the cracks.
Fixes#1096
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
PotentSulfurBlock.animateTick sends two sulfur_bubbles up through a water
source above a wet potent sulfur block, and one time in ten plays
block.potent_sulfur.noxious_gas. SulfurBubbleParticle rises at -0.04
gravity with 0.85 friction, wiggles sideways, grows from 0.02 to 0.15 and
pops when it leaves a water source, stops rising or travels 3 blocks. Its
provider passes yAux as the Z speed, which is kept.
The particle providers harness gets water worlds for sulfur_bubbles,
bubble and bubble_column_up.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
🤖 Agent: merged. Verify and CI parity pass, and an independent review found no blocking issue. The release, launcher and promote workflows stay disabled with RELEASES_PAUSED=1. Without .github/release-line.txt the train decides exactly as before (checked against every existing tag).
ServerWaypointManager.removePlayer disconnects every waypoint the player
was receiving: a player who goes to another level gets an untrack for each
player it tracked in the one it left. Horizon's per-level managers tick
with the players in their own level only, so the untrack had no connection
to go to and the player kept the old level's markers.
Each level's manager now also gets the connections of the players in the
other levels, for these untracks.
The player-targets and dimension-players harnesses compare the waypoints
as each step leaves them (the last packet for each waypoint): arriving in a
level, vanilla sends the same waypoint up to three times within the step,
and the packet by packet order is test_locator_bar_parity's. Both pass:
123 and 40 lines identical.
Part of #843
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Vanilla keeps a ServerWaypointManager per level: a player in another level
is neither a transmitter nor a receiver there. Horizon passed every player
to one manager whatever their dimension, so a player who went to the
Nether stayed tracked at their Nether coordinates by the players left in
the Overworld (`track Bob block 0 100 0`), and nothing was re-tracked when
they came back.
Each level now has its own manager, ticked with the players in that level:
a player changing level leaves the old one (untracked for everyone there,
as ServerLevel.removePlayerImmediately) and joins the new one
(addDuringTeleport). The player-targets and dimension-players harnesses
now compare the waypoints too, instead of leaving them out.
Fixes#843
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A sleeping guest stood on top of its bed for everyone else: the server
sent its pose but never its bed (LivingEntity.SLEEPING_POS goes only to
the sleeper itself), Horizon's clients had no sleeping pose for other
players, and the host's own models of its guests ignored the bed. A
player paired with the sleeper later (the host walking up from afar)
saw the same.
The tracked state of a sleeping player (the host or a guest) now holds
its bed, so pairing and updates send it, and its removal sends the empty
position back; the clients and the host's guest models lie the player in
the bed as LivingEntityRenderer.setupRotations does for Pose.SLEEPING
(the villagers' sleeping pose, by the bed's facing).
lan_e2e `sleep`: the host draws the sleeping guest lying, the guest the
sleeping host, and neither once they are up.
Fixes#1045
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Primed TNT (and falling blocks, projectiles) spawned from /summon get
their entity id only when first tracked, so the summon found no new id
and answered "Unable to summon entity" though the entity was there and
went off. The summon now also counts those lists, and names the type:
"Summoned new Primed TNT", as vanilla.
Test: a TNT summon in the command execution corpus (world group:
125/126 match vanilla; the one left, /waypoint list, was there before).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit dd733684bc8a2efca2b2fa76fc54d6eb48608103)
On a dedicated server (and single player's server thread) the End is ticked
with no local player, and `tick_fight` returned before spawning the dragon:
players in the End found crystals but never a dragon.
- The fight finds its players as `EnderDragonFight.updatePlayers` does, every
20 ticks: every player alive within 192 blocks of (0, 128, 0), the host and
the network players in the level alike. Scanning the state, the respawn
sequence, `createNewDragon` and the crystal count run while it has one;
the dragon and crystals tick whenever the End does.
- The dragon is tracked to network players (`minecraft:ender_dragon`, its
health and `DATA_PHASE` as vanilla pairs them, no attribute instances) and
reserves its eight part ids after its own, as `EnderDragon`'s constructor
does, so clients can attack the parts; a network player's attack on a part
or an end crystal is aimed at it.
tools/test_server_dragon_parity.py sends a lone vanilla-codec client to the
End of vanilla's dedicated server and of Horizon's: the fight starts and the
dragon is tracked with the same spawn data, synched data entries and
attributes. VanillaProtocolClient's entity mode answers a scene's teleport
with the acceptance alone, as the 26.3 client does.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 618db927d93bbcf7f3669ad0d630377c4646729d)
docs/versioning.md: with .github/release-line.txt (MAJOR.MINOR) the train tags game releases
vMAJOR.MINOR.PATCH and launcher releases launcher@MAJOR.MINOR.PATCH, the patch after the newest
release on the line; the line's first release goes out at once (still not while RELEASES_PAUSED is
set). Without the file nothing changes: vYYYY.MM.DD[.N] and launcher-vX.Y.Z. The file is not added
here; the switch to 0.2 is a separate one-line pull request for the day Ludovic says go.
- tag_key: every 0.2 tag ranks above every dated or launcher-v tag; semver order within, a
pre-release before its release. release_channels.py uses the same key and tag test, so promotion
and "latest only moves forward" work across the switch.
- A line's first release says so in its notes; 0.2.0's explains the numbering and how a server
that says it is up to date takes it (horizon-server update --version v0.2.0).
- launcher.yml strips either prefix for HORIZON_LAUNCHER_VERSION and passes HORIZON_LAUNCHER_TAG,
which the launcher uses to know its own line.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Low leaves can hide every face of the trunk's bottom log from where the
walk stops ("no face of block ... is visible from here"). The scenario
now breaks inside the tree loop and moves on to the next tree, as it
already did for one it cannot reach.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- survival and ui asserted that the Create New World click itself
answered `playing`. Since 7f4193f8 the in-frame world is prepared off
the UI thread behind the title screen, so the click answers `title`
and both scenarios failed in the frame (main's default) every time.
They now wait for `loaded`, as the other scenarios do.
- The survival spawn is random within the spawn radius, on the first
full top face below the MOTION_BLOCKING height
(PlayerSpawnFinder.getLevelRespawnPos), so a tree's leaves too: from
there no tree was reachable within goto's three-block drops. The
scenario now drops the player to the ground under the leaves first.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
check_xp makes the host a spectator, out of the orbs' way, and left it
one for the rest of the run. A spectator sinks (Player.travel keeps 0.6
of its vertical speed each tick, about 0.2 blocks from standing), so the
next check that made it survival again, swings, landed it inside the
floor with the guest teleported beside it: the guest's feet were in the
floor's stone, which hid the dirt it tills from every angle ("no face of
block ... is visible from here"). It failed only after the earlier
checks, never alone.
check_xp now ends in survival where the host stood, as check_trials
already does.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The oracle prints every ProtoChunk postprocessing position and chunk_dump
prints Horizon's, so a chunk that schedules different fluid or shape
updates after generation (the blocks that later tick and drop items in
fresh chunks, #996) fails the harness.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>