Client of a server: abilities from the server, flight sent back

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>
This commit is contained in:
Ludovic Marie
2026-10-21 21:19:46 +02:00
parent c1b5fe95d2
commit 86b58b71fa
4 changed files with 109 additions and 4 deletions
+33 -2
View File
@@ -99,6 +99,10 @@ pub(super) struct Remote {
last_input: u8,
was_sprinting: bool,
carried: Option<usize>,
/// The last ClientboundPlayerAbilitiesPacket. Vanilla's LocalPlayer
/// holds its abilities from the login on; here the player is made at
/// the first teleport, which takes them then.
abilities: Option<play::PlayerAbilities>,
loaded_sent: bool,
/// The view distance last sent in ClientInformation.
sent_view: i8,
@@ -313,6 +317,7 @@ impl Game<'_> {
last_input: 0,
was_sprinting: false,
carried: None,
abilities: None,
loaded_sent: false,
sent_view: view,
predictions: HashMap::new(),
@@ -1840,9 +1845,10 @@ impl Game<'_> {
},
C::PlayerAbilities(p) => {
self.creative = p.flags & 8 != 0;
if let Some(player) = &mut self.player {
player.flying_speed = p.flying_speed;
if let Some(r) = self.remote.as_mut() {
r.abilities = Some(p);
}
self.apply_remote_abilities();
}
C::SetHeldSlot(p) => {
self.selected = p.slot.clamp(0, 8) as usize;
@@ -2485,6 +2491,7 @@ impl Game<'_> {
self.previous_eye = 1.62;
self.clock.reset();
self.apply_remote_health();
self.apply_remote_abilities();
}
}
self.previous_position = position;
@@ -2620,6 +2627,7 @@ impl Game<'_> {
[player.velocity.x, player.velocity.y, player.velocity.z],
[player.position.x, player.position.y, player.position.z],
);
let was_flying = player.flying;
player.yaw = self.yaw;
let dead = self.screen == Screen::Dead;
// LivingEntity.isImmobile: a sleeper lies still in the bed.
@@ -2642,6 +2650,9 @@ impl Game<'_> {
}
.controlled_simulation_tick(keys)?;
}
// LocalPlayer.onUpdateAbilities: flight turned on or off (a double
// jump, a spectator, landing) is sent to the server.
let flying = player.flying;
let events = std::mem::take(&mut player.events);
self.previous_eye = self.eye;
self.eye += (player.dimensions.eye_height - self.eye) * 0.5;
@@ -2676,9 +2687,29 @@ impl Game<'_> {
if !dead {
self.remote_tick_using();
}
if flying != was_flying {
self.send(S::PlayerAbilities(play::PlayerAbilitiesRequest {
flags: if flying { 2 } else { 0 },
}));
}
self.remote_send_state(input);
Ok(())
}
/// ClientPacketListener.handlePlayerAbilities: the player flies, may fly
/// and is invulnerable as the server says (bits 2, 4 and 1).
fn apply_remote_abilities(&mut self) {
let (Some(player), Some(a)) = (
self.player.as_mut(),
self.remote.as_ref().and_then(|r| r.abilities.as_ref()),
) else {
return;
};
player.invulnerable = a.flags & 1 != 0;
player.flying = a.flags & 2 != 0;
player.may_fly = a.flags & 4 != 0;
player.flying_speed = a.flying_speed;
}
/// The local player's share of every touching entity's
/// `LivingEntity.pushEntities`: on a client `EntitySelector.pushableBy`
/// lets entities push only the local player, so the server never sends
+13
View File
@@ -1872,6 +1872,7 @@ impl Hub {
// (handlePlayerKnownMovement), PlayerInput once loaded.
let acted = match &packet {
S::AcceptTeleportation(_)
| S::PlayerAbilities(_)
| S::MovePlayerStatus(_)
| S::MovePlayerRot(_)
| S::PlayerLoaded(_)
@@ -1909,6 +1910,11 @@ impl Hub {
self.position_change(i, [p.x, p.y, p.z], rot, 0, ctx, events);
}
}
// handlePlayerAbilities: the client flies only if it may.
S::PlayerAbilities(p) => {
let g = &mut self.guests[i];
g.flying = p.flags & 2 != 0 && (g.creative() || g.spectator());
}
S::MovePlayerPos(p) => {
self.move_player(i, Some([p.x, p.y, p.z]), None, p.flags, ctx, events);
}
@@ -2183,6 +2189,13 @@ impl Hub {
return;
};
g.game_mode = mode;
// GameType.updatePlayerAbilities: a spectator flies, survival and
// adventure don't, creative keeps what it had.
if g.spectator() {
g.flying = true;
} else if !g.creative() {
g.flying = false;
}
let uuid = g.uuid;
g.send(&C::GameEvent(play::GameEvent {
event: game_event::CHANGE_GAME_MODE,
@@ -1674,6 +1674,8 @@ packet!(
);
packet!(ChangeDifficultyRequest { difficulty: i32 => VarInt });
packet!(LockDifficulty { locked: bool => Bool });
// ServerboundPlayerAbilitiesPacket: only whether the player flies (2).
packet!(PlayerAbilitiesRequest { flags: i8 => Byte });
packet!(SetGameRule { entries: Vec<GameRuleEntry> => List<GameRuleEntry> });
packet!(ChunkBatchReceived { chunks_per_tick: f32 => Float });
packet!(
@@ -1786,6 +1788,7 @@ packet_enum!(Serverbound, crate::ids::play::serverbound {
MovePlayerStatus(MovePlayerStatus) = MOVE_PLAYER_STATUS_ONLY,
PickItemFromBlock(PickItemFromBlock) = PICK_ITEM_FROM_BLOCK,
PingRequest(crate::packets::status::Ping) = PING_REQUEST,
PlayerAbilities(PlayerAbilitiesRequest) = PLAYER_ABILITIES,
PlayerAction(PlayerAction) = PLAYER_ACTION,
PlayerCommand(PlayerCommand) = PLAYER_COMMAND,
PlayerInput(PlayerInput) = PLAYER_INPUT,
@@ -1805,6 +1808,17 @@ mod tests {
use super::*;
use crate::{chunk::BlockEntityInfo, packets::round_trip, text::literal};
#[test]
fn serverbound_abilities_carry_only_flying() {
// ServerboundPlayerAbilitiesPacket.write: one byte, 2 when flying.
let flying = Serverbound::PlayerAbilities(PlayerAbilitiesRequest { flags: 2 });
assert_eq!(
flying.encode(),
[crate::ids::play::serverbound::PLAYER_ABILITIES as u8, 2]
);
round_trip(flying, Serverbound::encode, Serverbound::decode);
}
#[test]
fn world_options_packets_match_vanilla_stream_codecs() {
// mcsrc.dev 26.3: difficulty is a VarInt, locking is a Boolean,
+49 -2
View File
@@ -74,6 +74,9 @@ address. The script then checks, from both sides, what a guest's game used to ge
server's game time after the guest's game stalls for a few seconds (#848).
- growth: far from the host, the chunks around the guest tick (#890): water placed there flows
and wheat on farmland grows (random ticks), however the host runs its world.
- flight: a player in creative double-taps jump and flies, stays up, and stops flying in survival:
the guest, and on the server thread the host's window too, take what may fly from the
server's abilities (ClientPacketListener.handlePlayerAbilities).
- light: the guest's light matches the host's: around a torch placed near it, under a roof and
once a block of the roof is removed under the sky, and in the last chunk it tracks next to
glowstone in a chunk it doesn't (only the server's light updates bring that one).
@@ -111,7 +114,7 @@ ROOT = Path(__file__).resolve().parents[1]
GUEST_NAME = 'Guest'
# The host plays single player on its server thread (--server-thread).
SERVER_THREAD = False
CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'trials', 'clicks', 'sleep', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth']
CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'trials', 'clicks', 'sleep', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight']
class Game:
@@ -1607,6 +1610,50 @@ def same_light(host, guest, lo, hi, what, ticks=100):
f'{h["sky"][i]} block {h["block"][i]}, guest sky {g["sky"][i]} block {g["block"][i]}')
def check_flight(host, guest, out):
def double_jump(game):
# LocalPlayer.aiStep: a second jump press within 7 ticks of the first toggles flight.
for hold in (1, 4):
game.raw('key', 'space', 'down')
game.wait(hold)
game.raw('key', 'space', 'up')
game.wait(2)
game.wait(10)
return game('state')['player']
def set_mode(game, mode):
# On a client of a server the mode and its abilities (may fly) come back with the server's
# answer, later when the machine is busy: a double jump before them is two plain jumps.
game('command', command=f'gamemode {mode}')
for _ in range(100):
if game('state').get('gamemode') == mode:
break
game.wait(1)
game.wait(10)
players = [('guest', guest)] + ([('host', host)] if SERVER_THREAD else [])
seen = {}
try:
for name, game in players:
set_mode(game, 'creative')
ground = game('state')['player']
up = double_jump(game)
game.wait(20)
later = game('state')['player']
set_mode(game, 'survival')
fell = game('state')['player']
seen[name] = {'flying': up['flying'], 'rose': round(up['position'][1] - ground['position'][1], 2),
'stayed': round(later['position'][1] - up['position'][1], 2),
'survival_flying': fell['flying']}
finally:
for _, game in players:
game('command', command='gamemode survival')
for name, s in seen.items():
assert s['flying'] and s['rose'] > 1 and abs(s['stayed']) < 0.1, f'{name} does not fly in creative: {seen}'
assert not s['survival_flying'], f'{name} still flies in survival: {seen}'
return seen
def check_growth(host, guest, out):
"""Block ticks near a guest 1000 blocks from the host: only the guest's tickets tick them."""
x0, y0, z0 = pos_of(guest)
@@ -1712,7 +1759,7 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'name
'xp': check_xp, 'objects': check_objects, 'projectiles': check_projectiles,
'light': check_light, 'plates': check_plates,
'swings': check_swings, 'cracks': check_cracks,
'time': check_time, 'growth': check_growth}
'time': check_time, 'growth': check_growth, 'flight': check_flight}
def run(ctl, out, resources, checks):