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:
@@ -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
|
||||
|
||||
@@ -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
@@ -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):
|
||||
|
||||
Reference in New Issue
Block a user