#656 handles ClientboundChangeDifficultyPacket and refreshes the World
Options screen too; this branch's own arm became unreachable.
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>
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>
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>
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>
Every PR of the startup batch adds a different tools/profile_client_startup.py,
so any two of them conflict. This one becomes tools/profile_shared_json.py; its
guide and tools/profile_gameplay_decode.py follow.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>