//

// Source code recreated from a .class file by IntelliJ IDEA

// (powered by Fernflower decompiler)
//

package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link].ChatMessageC2SPacket;
import [Link].ClientStatusC2SPacket;
import [Link].CommandExecutionC2SPacket;
import [Link].CustomPayloadC2SPacket;
import [Link].KeepAliveC2SPacket;
import [Link].MessageAcknowledgmentC2SPacket;
import [Link].PlayPongC2SPacket;
import [Link].PlayerMoveC2SPacket;
import [Link].PlayerSessionC2SPacket;
import [Link].ResourcePackStatusC2SPacket;
import [Link].TeleportConfirmC2SPacket;
import [Link].VehicleMoveC2SPacket;
import [Link];
import [Link];
import [Link].AdvancementUpdateS2CPacket;
import [Link].BlockBreakingProgressS2CPacket;
import [Link].BlockEntityUpdateS2CPacket;
import [Link].BlockEventS2CPacket;
import [Link].BlockUpdateS2CPacket;
import [Link].BossBarS2CPacket;
import [Link].BundleS2CPacket;
import [Link].ChatMessageS2CPacket;
import [Link].ChatSuggestionsS2CPacket;
import [Link].ChunkBiomeDataS2CPacket;
import [Link];
import [Link].ChunkDataS2CPacket;
import [Link].ChunkDeltaUpdateS2CPacket;
import [Link].ChunkLoadDistanceS2CPacket;
import [Link].ChunkRenderDistanceCenterS2CPacket;
import [Link].ClearTitleS2CPacket;
import [Link].CloseScreenS2CPacket;
import [Link].CommandSuggestionsS2CPacket;
import [Link].CommandTreeS2CPacket;
import [Link].CooldownUpdateS2CPacket;
import [Link].CraftFailedResponseS2CPacket;
import [Link].CustomPayloadS2CPacket;
import [Link].DamageTiltS2CPacket;
import [Link].DeathMessageS2CPacket;
import [Link].DifficultyS2CPacket;
import [Link].DisconnectS2CPacket;
import [Link].EndCombatS2CPacket;
import [Link].EnterCombatS2CPacket;
import [Link].EntitiesDestroyS2CPacket;
import [Link].EntityAnimationS2CPacket;
import [Link].EntityAttachS2CPacket;
import [Link].EntityAttributesS2CPacket;
import [Link].EntityDamageS2CPacket;
import [Link].EntityEquipmentUpdateS2CPacket;
import [Link].EntityPassengersSetS2CPacket;
import [Link].EntityPositionS2CPacket;
import [Link].EntityS2CPacket;
import [Link].EntitySetHeadYawS2CPacket;
import [Link].EntitySpawnS2CPacket;
import [Link].EntityStatusEffectS2CPacket;
import [Link].EntityStatusS2CPacket;
import [Link].EntityTrackerUpdateS2CPacket;
import [Link].EntityVelocityUpdateS2CPacket;
import [Link].ExperienceBarUpdateS2CPacket;
import [Link].ExperienceOrbSpawnS2CPacket;
import [Link].ExplosionS2CPacket;
import [Link].FeaturesS2CPacket;
import [Link].GameJoinS2CPacket;
import [Link].GameMessageS2CPacket;
import [Link].GameStateChangeS2CPacket;
import [Link].HealthUpdateS2CPacket;
import [Link].InventoryS2CPacket;
import [Link].ItemPickupAnimationS2CPacket;
import [Link].KeepAliveS2CPacket;
import [Link];
import [Link].LightUpdateS2CPacket;
import [Link].LookAtS2CPacket;
import [Link].MapUpdateS2CPacket;
import [Link].NbtQueryResponseS2CPacket;
import [Link].OpenHorseScreenS2CPacket;
import [Link].OpenScreenS2CPacket;
import [Link].OpenWrittenBookS2CPacket;
import [Link].OverlayMessageS2CPacket;
import [Link].ParticleS2CPacket;
import [Link].PlayPingS2CPacket;
import [Link].PlaySoundFromEntityS2CPacket;
import [Link].PlaySoundS2CPacket;
import [Link].PlayerAbilitiesS2CPacket;
import [Link].PlayerActionResponseS2CPacket;
import [Link].PlayerListHeaderS2CPacket;
import [Link].PlayerListS2CPacket;
import [Link].PlayerPositionLookS2CPacket;
import [Link].PlayerRemoveS2CPacket;
import [Link].PlayerRespawnS2CPacket;
import [Link].PlayerSpawnPositionS2CPacket;
import [Link].PlayerSpawnS2CPacket;
import [Link];
import [Link].ProfilelessChatMessageS2CPacket;
import [Link].RemoveEntityStatusEffectS2CPacket;
import [Link].RemoveMessageS2CPacket;
import [Link].ResourcePackSendS2CPacket;
import [Link].ScoreboardDisplayS2CPacket;
import [Link].ScoreboardObjectiveUpdateS2CPacket;
import [Link].ScoreboardPlayerUpdateS2CPacket;
import [Link].ScreenHandlerPropertyUpdateS2CPacket;
import [Link].ScreenHandlerSlotUpdateS2CPacket;
import [Link].SelectAdvancementTabS2CPacket;
import [Link].ServerMetadataS2CPacket;
import [Link].SetCameraEntityS2CPacket;
import [Link].SetTradeOffersS2CPacket;
import [Link].SignEditorOpenS2CPacket;
import [Link].SimulationDistanceS2CPacket;
import [Link].StatisticsS2CPacket;
import [Link].StopSoundS2CPacket;
import [Link].SubtitleS2CPacket;
import [Link].SynchronizeRecipesS2CPacket;
import [Link].SynchronizeTagsS2CPacket;
import [Link].TeamS2CPacket;
import [Link].TitleFadeS2CPacket;
import [Link].TitleS2CPacket;
import [Link].UnloadChunkS2CPacket;
import [Link].UnlockRecipesS2CPacket;
import [Link].UpdateSelectedSlotS2CPacket;
import [Link].VehicleMoveS2CPacket;
import [Link].WorldBorderCenterChangedS2CPacket;
import [Link].WorldBorderInitializeS2CPacket;
import [Link].WorldBorderInterpolateSizeS2CPacket;
import [Link].WorldBorderSizeChangedS2CPacket;
import
[Link].WorldBorderWarningBlocksChangedS2CPacket;
import
[Link].WorldBorderWarningTimeChangedS2CPacket;
import [Link].WorldEventS2CPacket;
import [Link].WorldTimeUpdateS2CPacket;
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link].Vec3d;
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

@Environment([Link])
public class ClientPlayNetworkHandler implements TickablePacketListener,
ClientPlayPacketListener {
private static final Logger LOGGER = [Link]();
private static final Text DISCONNECT_LOST_TEXT =
[Link]("[Link]");
private static final Text UNSECURE_SERVER_TOAST_TITLE =
[Link]("[Link]");
private static final Text UNSECURE_SERVER_TOAST_TEXT =
[Link]("[Link]");
private static final Text INVALID_PACKET_TEXT =
[Link]("[Link].invalid_packet");
private static final Text CHAT_VALIDATION_FAILED_TEXT =
[Link]("[Link].chat_validation_failed");
private static final int ACKNOWLEDGMENT_BATCH_SIZE = 64;
private final ClientConnection connection;
 private final List<QueuedPacket> queuedPackets = new ArrayList();
@Nullable
private final ServerInfo serverInfo;
private final GameProfile profile;
private final Screen loginScreen;
private final MinecraftClient client;
private ClientWorld world;
private [Link] worldProperties;
private final Map<UUID, PlayerListEntry> playerListEntries = [Link]();
private final Set<PlayerListEntry> listedPlayerListEntries = new
ReferenceOpenHashSet();
private final ClientAdvancementManager advancementHandler;
private final ClientCommandSource commandSource;
private final DataQueryHandler dataQueryHandler = new DataQueryHandler(this);
private int chunkLoadDistance = 3;
private int simulationDistance = 3;
private final Random random = [Link]();
private CommandDispatcher<CommandSource> commandDispatcher = new
CommandDispatcher();
private final RecipeManager recipeManager = new RecipeManager();
private final UUID sessionId = [Link]();
private Set<RegistryKey<World>> worldKeys;
private CombinedDynamicRegistries<ClientDynamicRegistryType>
combinedDynamicRegistries =
[Link]();
private FeatureSet enabledFeatures;
private final WorldSession worldSession;
@Nullable
private ClientPlayerSession session;
private [Link] messagePacker;
private LastSeenMessagesCollector lastSeenMessagesCollector;
private MessageSignatureStorage signatureStorage;

public ClientPlayNetworkHandler(MinecraftClient client, Screen screen,

ClientConnection connection, @Nullable ServerInfo serverInfo, GameProfile profile,
WorldSession worldSession) {
[Link] = FeatureFlags.DEFAULT_ENABLED_FEATURES;
[Link] = [Link];
[Link] = new LastSeenMessagesCollector(20);
[Link] = [Link]();
[Link] = client;
[Link] = screen;
[Link] = connection;
[Link] = serverInfo;
[Link] = profile;
[Link] = new ClientAdvancementManager(client,
worldSession);
[Link] = new ClientCommandSource(this, client);
[Link] = worldSession;
}

public ClientCommandSource getCommandSource() {

return [Link];
}

public void clearWorld() {

[Link] = null;
[Link]();
}
 public RecipeManager getRecipeManager() {
return [Link];
}

public void onGameJoin(GameJoinS2CPacket packet) {

[Link](packet, this, [Link]);
[Link] = new
ClientPlayerInteractionManager([Link], this);
[Link] =
[Link]([Link], new
[Link][]{[Link]()});
if (![Link]()) {

[Link]().streamAllRegistries().f
orEach((entry) -> [Link]().clearTags());
}

List<RegistryKey<World>> list = [Link]([Link]());

[Link](list);
[Link] = [Link](list);
RegistryKey<World> registryKey = [Link]();
RegistryEntry<DimensionType> registryEntry =
[Link]().get([Link]
ION_TYPE).entryOf([Link]());
[Link] = [Link]();
[Link] = [Link]();
boolean bl = [Link]();
boolean bl2 = [Link]();
[Link] properties = new
[Link]([Link], [Link](), bl2);
[Link] = properties;
int var10007 = [Link];
int var10008 = [Link];
MinecraftClient var10009 = [Link];
[Link](var10009);
[Link] = new ClientWorld(this, properties, registryKey, registryEntry,
var10007, var10008, var10009::getProfiler, [Link], bl,
packet.sha256Seed());
[Link]([Link]);
if ([Link] == null) {
[Link] =
[Link]([Link], new StatHandler(), new
ClientRecipeBook());
[Link](-180.0F);
if ([Link]() != null) {

[Link]().setLocalPlayerUuid([Link]());
}
}

[Link]();
[Link]();
int i = [Link]();
[Link](i);
[Link](i, [Link]);
[Link] = new KeyboardInput([Link]);
[Link]([Link]);
[Link] = [Link];
 [Link](new DownloadingTerrainScreen());
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link]([Link](),
[Link]());
[Link]([Link]());
[Link]();
[Link](new
CustomPayloadC2SPacket([Link], (new
PacketByteBuf([Link]())).writeString([Link]
())));
[Link] = null;
[Link] = new LastSeenMessagesCollector(20);
[Link] = [Link]();
if ([Link]()) {
[Link]().fetchKeyPair().thenAcceptAsync((keyPair) -
> [Link](this::updateKeyPair), [Link]);
}

[Link]([Link](), [Link]());
[Link]().save([Link]);
}

public void onEntitySpawn(EntitySpawnS2CPacket packet) {

[Link](packet, this, [Link]);
EntityType<?> entityType = [Link]();
Entity entity = [Link]([Link]);
if (entity != null) {
[Link](packet);
int i = [Link]();
[Link](i, entity);
[Link](entity);
} else {
[Link]("Skipping Entity with id {}", entityType);
}

private void playSpawnSound(Entity entity) {

if (entity instanceof AbstractMinecartEntity) {
[Link]().play(new
MovingMinecartSoundInstance((AbstractMinecartEntity)entity));
} else if (entity instanceof BeeEntity) {
boolean bl = ((BeeEntity)entity).hasAngerTime();
AbstractBeeSoundInstance abstractBeeSoundInstance;
if (bl) {
abstractBeeSoundInstance = new
AggressiveBeeSoundInstance((BeeEntity)entity);
} else {
abstractBeeSoundInstance = new
PassiveBeeSoundInstance((BeeEntity)entity);
}

[Link]().playNextTick(abstractBeeSoundInstance);
}

}
 public void onExperienceOrbSpawn(ExperienceOrbSpawnS2CPacket packet) {
[Link](packet, this, [Link]);
double d = [Link]();
double e = [Link]();
double f = [Link]();
Entity entity = new ExperienceOrbEntity([Link], d, e, f,
[Link]());
[Link](d, e, f);
[Link](0.0F);
[Link](0.0F);
[Link]([Link]());
[Link]([Link](), entity);
}

public void onEntityVelocityUpdate(EntityVelocityUpdateS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]());
if (entity != null) {
[Link]((double)[Link]() /
(double)8000.0F, (double)[Link]() / (double)8000.0F,
(double)[Link]() / (double)8000.0F);
}
}

public void onEntityTrackerUpdate(EntityTrackerUpdateS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]());
if (entity != null) {
[Link]().writeUpdatedEntries([Link]());
}

public void onPlayerSpawn(PlayerSpawnS2CPacket packet) {

[Link](packet, this, [Link]);
PlayerListEntry playerListEntry =
[Link]([Link]());
if (playerListEntry == null) {
[Link]("Server attempted to add player prior to sending player
info (Player id {})", [Link]());
} else {
double d = [Link]();
double e = [Link]();
double f = [Link]();
float g = (float)([Link]() * 360) / 256.0F;
float h = (float)([Link]() * 360) / 256.0F;
int i = [Link]();
OtherClientPlayerEntity otherClientPlayerEntity = new
OtherClientPlayerEntity([Link], [Link]());
[Link](i);
[Link](d, e, f);
[Link](d, e, f, g, h);
[Link]();
[Link](i, otherClientPlayerEntity);
}
}

public void onEntityPosition(EntityPositionS2CPacket packet) {

 [Link](packet, this, [Link]);
Entity entity = [Link]([Link]());
if (entity != null) {
double d = [Link]();
double e = [Link]();
double f = [Link]();
[Link](d, e, f);
if (![Link]()) {
float g = (float)([Link]() * 360) / 256.0F;
float h = (float)([Link]() * 360) / 256.0F;
[Link](d, e, f, g, h, 3, true);
[Link]([Link]());
}

}
}

public void onUpdateSelectedSlot(UpdateSelectedSlotS2CPacket packet) {

[Link](packet, this, [Link]);
if ([Link]([Link]())) {
[Link]().selectedSlot = [Link]();
}

public void onEntity(EntityS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]);
if (entity != null) {
if (![Link]()) {
if ([Link]()) {
TrackedPosition trackedPosition = [Link]();
Vec3d vec3d =
[Link]((long)[Link](), (long)[Link](),
(long)[Link]());
[Link](vec3d);
float f = [Link]() ? (float)([Link]() * 360)
/ 256.0F : [Link]();
float g = [Link]() ? (float)([Link]() *
360) / 256.0F : [Link]();
[Link]([Link](),
[Link](), [Link](), f, g, 3, false);
} else if ([Link]()) {
float h = (float)([Link]() * 360) / 256.0F;
float i = (float)([Link]() * 360) / 256.0F;
[Link]([Link](),
[Link](), [Link](), h, i, 3, false);
}

[Link]([Link]());
}

}
}

public void onEntitySetHeadYaw(EntitySetHeadYawS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]);
if (entity != null) {
 float f = (float)([Link]() * 360) / 256.0F;
[Link](f, 3);
}
}

public void onEntitiesDestroy(EntitiesDestroyS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]().forEach((entityId) ->
[Link](entityId, [Link]));
}

public void onPlayerPositionLook(PlayerPositionLookS2CPacket packet) {

[Link](packet, this, [Link]);
PlayerEntity playerEntity = [Link];
Vec3d vec3d = [Link]();
boolean bl = [Link]().contains(PositionFlag.X);
boolean bl2 = [Link]().contains(PositionFlag.Y);
boolean bl3 = [Link]().contains(PositionFlag.Z);
double d;
double e;
if (bl) {
d = [Link]();
e = [Link]() + [Link]();
[Link] += [Link]();
[Link] += [Link]();
} else {
d = (double)0.0F;
e = [Link]();
[Link] = e;
[Link] = e;
}

double f;
double g;
if (bl2) {
f = [Link]();
g = [Link]() + [Link]();
[Link] += [Link]();
[Link] += [Link]();
} else {
f = (double)0.0F;
g = [Link]();
[Link] = g;
[Link] = g;
}

double h;
double i;
if (bl3) {
h = [Link]();
i = [Link]() + [Link]();
[Link] += [Link]();
[Link] += [Link]();
} else {
h = (double)0.0F;
i = [Link]();
[Link] = i;
[Link] = i;
}
 [Link](e, g, i);
[Link](d, f, h);
float j = [Link]();
float k = [Link]();
if ([Link]().contains(PositionFlag.X_ROT)) {
[Link]([Link]() + k);
[Link] += k;
} else {
[Link](k);
[Link] = k;
}

if ([Link]().contains(PositionFlag.Y_ROT)) {
[Link]([Link]() + j);
[Link] += j;
} else {
[Link](j);
[Link] = j;
}

[Link](new TeleportConfirmC2SPacket([Link]()));
[Link](new [Link]([Link](),
[Link](), [Link](), [Link](),
[Link](), false));
}

public void onChunkDeltaUpdate(ChunkDeltaUpdateS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]((pos, state) -> [Link](pos,
state, 19));
}

public void onChunkData(ChunkDataS2CPacket packet) {

[Link](packet, this, [Link]);
int i = [Link]();
int j = [Link]();
[Link](i, j, [Link]());
LightData lightData = [Link]();
[Link](() -> {
[Link](i, j, lightData);
WorldChunk worldChunk = [Link]().getWorldChunk(i,
j, false);
if (worldChunk != null) {
[Link](worldChunk, i, j);
}

});
}

public void onChunkBiomeData(ChunkBiomeDataS2CPacket packet) {

[Link](packet, this, [Link]);

for([Link] serialized :
[Link]()) {
[Link]().onChunkBiomeData([Link]().x,
[Link]().z, [Link]());
}
 for([Link] serialized :
[Link]()) {
[Link](new ChunkPos([Link]().x,
[Link]().z));
}

for([Link] serialized :
[Link]()) {
for(int i = -1; i <= 1; ++i) {
for(int j = -1; j <= 1; ++j) {
for(int k = [Link](); k <
[Link](); ++k) {

[Link]([Link]().x + i, k,
[Link]().z + j);
}
}
}
}

private void loadChunk(int x, int z, ChunkData chunkData) {

[Link]().loadChunkFromPacket(x, z,
[Link](), [Link](),
[Link](x, z));
}

private void scheduleRenderChunk(WorldChunk chunk, int x, int z) {

LightingProvider lightingProvider =
[Link]().getLightingProvider();
ChunkSection[] chunkSections = [Link]();
ChunkPos chunkPos = [Link]();

for(int i = 0; i < [Link]; ++i) {

ChunkSection chunkSection = chunkSections[i];
int j = [Link](i);
[Link]([Link](chunkPos, j),
[Link]());
[Link](x, j, z);
}

public void onUnloadChunk(UnloadChunkS2CPacket packet) {

[Link](packet, this, [Link]);
int i = [Link]();
int j = [Link]();
ClientChunkManager clientChunkManager = [Link]();
[Link](i, j);
[Link](packet);
}

private void unloadChunk(UnloadChunkS2CPacket packet) {

ChunkPos chunkPos = new ChunkPos([Link](), [Link]());
[Link](() -> {
LightingProvider lightingProvider = [Link]();
[Link](chunkPos, false);
 for(int i = [Link](); i <
[Link](); ++i) {
ChunkSectionPos chunkSectionPos = [Link](chunkPos,
i);
[Link]([Link],
chunkSectionPos, (ChunkNibbleArray)null);
[Link]([Link], chunkSectionPos,
(ChunkNibbleArray)null);
}

for(int i = [Link](); i <

[Link](); ++i) {
[Link]([Link](chunkPos,
i), true);
}

});
}

public void onBlockUpdate(BlockUpdateS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link](), [Link](), 19);
}

public void onDisconnect(DisconnectS2CPacket packet) {

[Link]([Link]());
}

public void onDisconnected(Text reason) {

[Link]();
[Link]();
if ([Link] != null) {
if ([Link] instanceof RealmsScreen) {
[Link](new
DisconnectedRealmsScreen([Link], DISCONNECT_LOST_TEXT, reason));
} else {
[Link](new DisconnectedScreen([Link],
DISCONNECT_LOST_TEXT, reason));
}
} else {
[Link](new DisconnectedScreen(new MultiplayerScreen(new
TitleScreen()), DISCONNECT_LOST_TEXT, reason));
}

public void sendPacket(Packet<?> packet) {

[Link](packet);
}

public void onItemPickupAnimation(ItemPickupAnimationS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]());
LivingEntity livingEntity =
(LivingEntity)[Link]([Link]());
if (livingEntity == null) {
livingEntity = [Link];
}
 if (entity != null) {
if (entity instanceof ExperienceOrbEntity) {
[Link]([Link](), [Link](), [Link](),
SoundEvents.ENTITY_EXPERIENCE_ORB_PICKUP, [Link], 0.1F,
([Link]() - [Link]()) * 0.35F + 0.9F, false);
} else {
[Link]([Link](), [Link](), [Link](),
SoundEvents.ENTITY_ITEM_PICKUP, [Link], 0.2F,
([Link]() - [Link]()) * 1.4F + 2.0F, false);
}

[Link](new
ItemPickupParticle([Link](),
[Link](), [Link], entity, livingEntity));
if (entity instanceof ItemEntity) {
ItemEntity itemEntity = (ItemEntity)entity;
ItemStack itemStack = [Link]();
if (![Link]()) {
[Link]([Link]());
}

if ([Link]()) {
[Link]([Link](),
[Link]);
}
} else if (!(entity instanceof ExperienceOrbEntity)) {
[Link]([Link](),
[Link]);
}
}

public void onGameMessage(GameMessageS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]().onGameMessage([Link](),
[Link]());
}

public void onChatMessage(ChatMessageS2CPacket packet) {

[Link](packet, this, [Link]);
Optional<MessageBody> optional =
[Link]().toBody([Link]);
Optional<[Link]> optional2 =
[Link]().toParameters([Link]
edRegistryManager());
if (![Link]() && ![Link]()) {
UUID uUID = [Link]();
PlayerListEntry playerListEntry = [Link](uUID);
if (playerListEntry == null) {
[Link](CHAT_VALIDATION_FAILED_TEXT);
} else {
PublicPlayerSession publicPlayerSession =
[Link]();
MessageLink messageLink;
if (publicPlayerSession != null) {
messageLink = new MessageLink([Link](), uUID,
[Link]());
} else {
 messageLink = [Link](uUID);
}

SignedMessage signedMessage = new SignedMessage(messageLink,

[Link](), (MessageBody)[Link](), [Link](),
[Link]());
if (!
[Link]().isVerified(signedMessage)) {
[Link](CHAT_VALIDATION_FAILED_TEXT);
} else {
[Link]().onChatMessage(signedMessage,
[Link](), ([Link])[Link]());
[Link](signedMessage);
}
}
} else {
[Link](INVALID_PACKET_TEXT);
}
}

public void onProfilelessChatMessage(ProfilelessChatMessageS2CPacket packet) {

[Link](packet, this, [Link]);
Optional<[Link]> optional =
[Link]().toParameters([Link]
nager());
if ([Link]()) {
[Link](INVALID_PACKET_TEXT);
} else {
[Link]().onProfilelessMessage([Link](),
([Link])[Link]());
}
}

public void onRemoveMessage(RemoveMessageS2CPacket packet) {

[Link](packet, this, [Link]);
Optional<MessageSignatureData> optional =
[Link]().getSignature([Link]);
if ([Link]()) {
[Link](INVALID_PACKET_TEXT);
} else {

[Link]((MessageSignatureData)[Link]());
if (!
[Link]().removeDelayedMessage((MessageSignatureData)optional
.get())) {

[Link]().removeMessage((MessageSignatureData)[Link]
());
}

}
}

public void onEntityAnimation(EntityAnimationS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]());
if (entity != null) {
if ([Link]() == 0) {
LivingEntity livingEntity = (LivingEntity)entity;
 [Link](Hand.MAIN_HAND);
} else if ([Link]() == 3) {
LivingEntity livingEntity = (LivingEntity)entity;
[Link](Hand.OFF_HAND);
} else if ([Link]() == 2) {
PlayerEntity playerEntity = (PlayerEntity)entity;
[Link](false, false);
} else if ([Link]() == 4) {
[Link](entity, [Link]);
} else if ([Link]() == 5) {
[Link](entity,
ParticleTypes.ENCHANTED_HIT);
}

}
}

public void onDamageTilt(DamageTiltS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]());
if (entity != null) {
[Link]([Link]());
}
}

public void onWorldTimeUpdate(WorldTimeUpdateS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
}

public void onPlayerSpawnPosition(PlayerSpawnPositionS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link](), [Link]());
Screen var3 = [Link];
if (var3 instanceof DownloadingTerrainScreen downloadingTerrainScreen) {
[Link]();
}

public void onEntityPassengersSet(EntityPassengersSetS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]());
if (entity == null) {
[Link]("Received passengers for unknown entity");
} else {
boolean bl = [Link]([Link]);
[Link]();

for(int i : [Link]()) {
Entity entity2 = [Link](i);
if (entity2 != null) {
[Link](entity, true);
if (entity2 == [Link] && !bl) {
if (entity instanceof BoatEntity) {
[Link] = [Link]();
[Link]([Link]());
 [Link]([Link]());
}

Text text = [Link]("[Link]", new Object[]

{[Link]()});
[Link](text, false);
[Link]().narrate(text);
}
}
}

}
}

public void onEntityAttach(EntityAttachS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]());
if (entity instanceof MobEntity) {
((MobEntity)entity).setHoldingEntityId([Link]());
}

private static ItemStack getActiveTotemOfUndying(PlayerEntity player) {

for(Hand hand : [Link]()) {
ItemStack itemStack = [Link](hand);
if ([Link](Items.TOTEM_OF_UNDYING)) {
return itemStack;
}
}

return new ItemStack(Items.TOTEM_OF_UNDYING);

}

public void onEntityStatus(EntityStatusS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]);
if (entity != null) {
switch ([Link]()) {
case 21:
[Link]().play(new
GuardianAttackSoundInstance((GuardianEntity)entity));
break;
case 35:
int i = 40;
[Link](entity,
ParticleTypes.TOTEM_OF_UNDYING, 30);
[Link]([Link](), [Link](),
[Link](), SoundEvents.ITEM_TOTEM_USE, [Link](), 1.0F, 1.0F,
false);
if (entity == [Link]) {

[Link](getActiveTotemOfUndying([Link]
r));
}
break;
case 63:
[Link]().play(new
SnifferDigSoundInstance((SnifferEntity)entity));
 break;
default:
[Link]([Link]());
}
}

public void onEntityDamage(EntityDamageS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]());
if (entity != null) {
[Link]([Link]([Link]));
}
}

public void onHealthUpdate(HealthUpdateS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link]());
[Link]().setFoodLevel([Link]());

[Link]().setSaturationLevel([Link]());
}

public void onExperienceBarUpdate(ExperienceBarUpdateS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link](),
[Link](), [Link]());
}

public void onPlayerRespawn(PlayerRespawnS2CPacket packet) {

[Link](packet, this, [Link]);
RegistryKey<World> registryKey = [Link]();
RegistryEntry<DimensionType> registryEntry =
[Link]().get([Link]
ION_TYPE).entryOf([Link]());
ClientPlayerEntity clientPlayerEntity = [Link];
int i = [Link]();
if (registryKey != [Link]().getRegistryKey()) {
Scoreboard scoreboard = [Link]();
Map<String, MapState> map = [Link]();
boolean bl = [Link]();
boolean bl2 = [Link]();
[Link] properties = new
[Link]([Link](),
[Link](), bl2);
[Link] = properties;
int var10007 = [Link];
int var10008 = [Link];
MinecraftClient var10009 = [Link];
[Link](var10009);
[Link] = new ClientWorld(this, properties, registryKey,
registryEntry, var10007, var10008, var10009::getProfiler,
[Link], bl, packet.getSha256Seed());
[Link](scoreboard);
[Link](map);
[Link]([Link]);
[Link](new DownloadingTerrainScreen());
}
 String string = [Link]();
[Link] = null;
if ([Link]()) {
[Link]();
}

ClientPlayerEntity clientPlayerEntity2;
if ([Link]((byte)2)) {
clientPlayerEntity2 =
[Link]([Link],
[Link](), [Link](),
[Link](), [Link]());
} else {
clientPlayerEntity2 =
[Link]([Link],
[Link](), [Link]());
}

[Link](i);
[Link] = clientPlayerEntity2;
if (registryKey != [Link]().getRegistryKey()) {
[Link]().stop();
}

[Link] = clientPlayerEntity2;
if ([Link]((byte)2)) {
List<[Link]<?>> list =
[Link]().getChangedEntries();
if (list != null) {
[Link]().writeUpdatedEntries(list);
}
}

if ([Link]((byte)1)) {

[Link]().setFrom([Link]());
}

[Link]();
[Link](string);
[Link](i, clientPlayerEntity2);
[Link](-180.0F);
[Link] = new KeyboardInput([Link]);
[Link](clientPlayerEntity2);

[Link]([Link]());

[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link] = [Link];
[Link] =
[Link];
if ([Link] instanceof DeathScreen ||
[Link] instanceof [Link]) {
[Link]((Screen)null);
}
 [Link]([Link](),
[Link]());
}

public void onExplosion(ExplosionS2CPacket packet) {

[Link](packet, this, [Link]);
Explosion explosion = new Explosion([Link], (Entity)null,
[Link](), [Link](), [Link](), [Link](),
[Link]());
[Link](true);

[Link]([Link]().add((double)packet.
getPlayerVelocityX(), (double)[Link](),
(double)[Link]()));
}

public void onOpenHorseScreen(OpenHorseScreenS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]());
if (entity instanceof AbstractHorseEntity) {
ClientPlayerEntity clientPlayerEntity = [Link];
AbstractHorseEntity abstractHorseEntity = (AbstractHorseEntity)entity;
SimpleInventory simpleInventory = new
SimpleInventory([Link]());
HorseScreenHandler horseScreenHandler = new
HorseScreenHandler([Link](), [Link](),
simpleInventory, abstractHorseEntity);
[Link] = horseScreenHandler;
[Link](new HorseScreen(horseScreenHandler,
[Link](), abstractHorseEntity));
}

public void onOpenScreen(OpenScreenS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link](), [Link],
[Link](), [Link]());
}

public void onScreenHandlerSlotUpdate(ScreenHandlerSlotUpdateS2CPacket packet)

{
[Link](packet, this, [Link]);
PlayerEntity playerEntity = [Link];
ItemStack itemStack = [Link]();
int i = [Link]();
[Link]().onSlotUpdate(itemStack);
if ([Link]() == -1) {
if (!([Link] instanceof CreativeInventoryScreen)) {
[Link](itemStack);
}
} else if ([Link]() == -2) {
[Link]().setStack(i, itemStack);
} else {
boolean bl = false;
Screen var7 = [Link];
if (var7 instanceof CreativeInventoryScreen) {
CreativeInventoryScreen creativeInventoryScreen =
(CreativeInventoryScreen)var7;
 bl = ![Link]();
}

if ([Link]() == 0 && [Link](i)) {

if (![Link]()) {
ItemStack itemStack2 =
[Link](i).getStack();
if ([Link]() || [Link]() <
[Link]()) {
[Link](5);
}
}

[Link](i,
[Link](), itemStack);
} else if ([Link]() ==
[Link] && ([Link]() != 0 || !bl)) {
[Link](i,
[Link](), itemStack);
}
}

public void onInventory(InventoryS2CPacket packet) {

[Link](packet, this, [Link]);
PlayerEntity playerEntity = [Link];
if ([Link]() == 0) {
[Link]([Link](),
[Link](), [Link]());
} else if ([Link]() == [Link])
{

[Link]([Link](),
[Link](), [Link]());
}

public void onSignEditorOpen(SignEditorOpenS2CPacket packet) {

[Link](packet, this, [Link]);
BlockPos blockPos = [Link]();
BlockEntity var4 = [Link](blockPos);
if (var4 instanceof SignBlockEntity signBlockEntity) {
[Link](signBlockEntity,
[Link]());
} else {
BlockState blockState = [Link](blockPos);
SignBlockEntity signBlockEntity2 = new SignBlockEntity(blockPos,
blockState);
[Link]([Link]);
[Link](signBlockEntity2,
[Link]());
}

public void onBlockEntityUpdate(BlockEntityUpdateS2CPacket packet) {

[Link](packet, this, [Link]);
 BlockPos blockPos = [Link]();
[Link](blockPos,
[Link]()).ifPresent((blockEntity) -> {
NbtCompound nbtCompound = [Link]();
if (nbtCompound != null) {
[Link](nbtCompound);
}

if (blockEntity instanceof CommandBlockBlockEntity &&

[Link] instanceof CommandBlockScreen) {

((CommandBlockScreen)[Link]).updateCommandBlock();
}

});
}

public void onScreenHandlerPropertyUpdate(ScreenHandlerPropertyUpdateS2CPacket

packet) {
[Link](packet, this, [Link]);
PlayerEntity playerEntity = [Link];
if ([Link] != null &&
[Link] == [Link]()) {
[Link]([Link](),
[Link]());
}

public void onEntityEquipmentUpdate(EntityEquipmentUpdateS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]());
if (entity != null) {
[Link]().forEach((pair) ->
[Link]((EquipmentSlot)[Link](), (ItemStack)[Link]()));
}

public void onCloseScreen(CloseScreenS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]();
}

public void onBlockEvent(BlockEventS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link](), [Link](),
[Link](), [Link]());
}

public void onBlockBreakingProgress(BlockBreakingProgressS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link](),
[Link](), [Link]());
}

public void onGameStateChange(GameStateChangeS2CPacket packet) {

[Link](packet, this, [Link]);
PlayerEntity playerEntity = [Link];
 [Link] reason = [Link]();
float f = [Link]();
int i = [Link](f + 0.5F);
if (reason == GameStateChangeS2CPacket.NO_RESPAWN_BLOCK) {

[Link]([Link]("[Link].not_valid"),
false);
} else if (reason == GameStateChangeS2CPacket.RAIN_STARTED) {
[Link]().setRaining(true);
[Link](0.0F);
} else if (reason == GameStateChangeS2CPacket.RAIN_STOPPED) {
[Link]().setRaining(false);
[Link](1.0F);
} else if (reason == GameStateChangeS2CPacket.GAME_MODE_CHANGED) {
[Link]([Link](i));
} else if (reason == GameStateChangeS2CPacket.GAME_WON) {
if (i == 0) {
[Link](new
ClientStatusC2SPacket(Mode.PERFORM_RESPAWN));
[Link](new DownloadingTerrainScreen());
} else if (i == 1) {
[Link](new CreditsScreen(true, () -> {
[Link](new
ClientStatusC2SPacket(Mode.PERFORM_RESPAWN));
[Link]((Screen)null);
}));
}
} else if (reason == GameStateChangeS2CPacket.DEMO_MESSAGE_SHOWN) {
GameOptions gameOptions = [Link];
if (f == 0.0F) {
[Link](new DemoScreen());
} else if (f == 101.0F) {

[Link]().addMessage([Link]("[Link]
", new Object[]{[Link](),
[Link](),
[Link](),
[Link]()}));
} else if (f == 102.0F) {

[Link]().addMessage([Link]("[Link]",
new Object[]{[Link]()}));
} else if (f == 103.0F) {

[Link]().addMessage([Link]("[Link]
y", new Object[]{[Link]()}));
} else if (f == 104.0F) {

[Link]().addMessage([Link]("[Link].6", new
Object[]{[Link]()}));
}
} else if (reason == GameStateChangeS2CPacket.PROJECTILE_HIT_PLAYER) {
[Link](playerEntity, [Link](),
[Link](), [Link](), SoundEvents.ENTITY_ARROW_HIT_PLAYER,
[Link], 0.18F, 0.45F);
} else if (reason == GameStateChangeS2CPacket.RAIN_GRADIENT_CHANGED) {
[Link](f);
} else if (reason == GameStateChangeS2CPacket.THUNDER_GRADIENT_CHANGED) {
[Link](f);
 } else if (reason == GameStateChangeS2CPacket.PUFFERFISH_STING) {
[Link](playerEntity, [Link](),
[Link](), [Link](), SoundEvents.ENTITY_PUFFER_FISH_STING,
[Link], 1.0F, 1.0F);
} else if (reason == GameStateChangeS2CPacket.ELDER_GUARDIAN_EFFECT) {
[Link](ParticleTypes.ELDER_GUARDIAN,
[Link](), [Link](), [Link](), (double)0.0F,
(double)0.0F, (double)0.0F);
if (i == 1) {
[Link](playerEntity, [Link](),
[Link](), [Link](), SoundEvents.ENTITY_ELDER_GUARDIAN_CURSE,
[Link], 1.0F, 1.0F);
}
} else if (reason == GameStateChangeS2CPacket.IMMEDIATE_RESPAWN) {
[Link](f == 0.0F);
}

public void onMapUpdate(MapUpdateS2CPacket packet) {

[Link](packet, this, [Link]);
MapRenderer mapRenderer = [Link]();
int i = [Link]();
String string = [Link](i);
MapState mapState = [Link](string);
if (mapState == null) {
mapState = [Link]([Link](), [Link](),
[Link]());
[Link](string, mapState);
}

[Link](mapState);
[Link](i, mapState);
}

public void onWorldEvent(WorldEventS2CPacket packet) {

[Link](packet, this, [Link]);
if ([Link]()) {
[Link]([Link](), [Link](),
[Link]());
} else {
[Link]([Link](), [Link](),
[Link]());
}

public void onAdvancements(AdvancementUpdateS2CPacket packet) {

[Link](packet, this, [Link]);
[Link](packet);
}

public void onSelectAdvancementTab(SelectAdvancementTabS2CPacket packet) {

[Link](packet, this, [Link]);
Identifier identifier = [Link]();
if (identifier == null) {
[Link]((Advancement)null, false);
} else {
Advancement advancement =
[Link]().get(identifier);
[Link](advancement, false);
}

public void onCommandTree(CommandTreeS2CPacket packet) {

[Link](packet, this, [Link]);
[Link] = new
CommandDispatcher([Link]([Link]([Link]
[Link](), [Link])));
}

public void onStopSound(StopSoundS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]().stopSounds([Link](),
[Link]());
}

public void onCommandSuggestions(CommandSuggestionsS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link](),
[Link]());
}

public void onSynchronizeRecipes(SynchronizeRecipesS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link]());
ClientRecipeBook clientRecipeBook = [Link]();
[Link]([Link](),
[Link]());
[Link](SearchManager.RECIPE_OUTPUT,
[Link]());
}

public void onLookAt(LookAtS2CPacket packet) {

[Link](packet, this, [Link]);
Vec3d vec3d = [Link]([Link]);
if (vec3d != null) {
[Link]([Link](), vec3d);
}

public void onNbtQueryResponse(NbtQueryResponseS2CPacket packet) {

[Link](packet, this, [Link]);
if (,
[Link]())) {
[Link]("Got unhandled response to tag query {}",
[Link]());
}

public void onStatistics(StatisticsS2CPacket packet) {

[Link](packet, this, [Link]);

for([Link]<Stat<?>, Integer> entry : [Link]().entrySet()) {

Stat<?> stat = (Stat)[Link]();
 int i = (Integer)[Link]();
[Link]().setStat([Link], stat,
i);
}

if ([Link] instanceof StatsListener) {

((StatsListener)[Link]).onStatsReady();
}

public void onUnlockRecipes(UnlockRecipesS2CPacket packet) {

[Link](packet, this, [Link]);
ClientRecipeBook clientRecipeBook = [Link]();
[Link]([Link]());
[Link] action = [Link]();
switch (action) {
case REMOVE:
for(Identifier identifier : [Link]()) {
Optional var13 = [Link](identifier);
[Link](clientRecipeBook);
[Link](clientRecipeBook::remove);
}
break;
case INIT:
for(Identifier identifier : [Link]()) {
Optional var10000 = [Link](identifier);
[Link](clientRecipeBook);
[Link](clientRecipeBook::add);
}

for(Identifier identifier : [Link]()) {

Optional var12 = [Link](identifier);
[Link](clientRecipeBook);
[Link](clientRecipeBook::display);
}
break;
case ADD:
for(Identifier identifier : [Link]()) {
[Link](identifier).ifPresent((recipe) -> {
[Link](recipe);
[Link](recipe);
if ([Link]()) {
[Link]([Link](),
recipe);
}

});
}
}

[Link]().forEach((recipeResultCollection) ->
[Link](clientRecipeBook));
if ([Link] instanceof RecipeBookProvider) {
((RecipeBookProvider)[Link]).refreshRecipeBook();
}

}
 public void onEntityStatusEffect(EntityStatusEffectS2CPacket packet) {
[Link](packet, this, [Link]);
Entity entity = [Link]([Link]());
if (entity instanceof LivingEntity) {
StatusEffect statusEffect = [Link]();
if (statusEffect != null) {
StatusEffectInstance statusEffectInstance = new
StatusEffectInstance(statusEffect, [Link](), [Link](),
[Link](), [Link](), [Link](),
(StatusEffectInstance)null,
[Link]([Link]()));
((LivingEntity)entity).setStatusEffect(statusEffectInstance,
(Entity)null);
}
}
}

public void onSynchronizeTags(SynchronizeTagsS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]().forEach(this::loadTags);
if (![Link]()) {
[Link]();
}

[Link]().reloadSearchProvider();
}

public void onFeatures(FeaturesS2CPacket packet) {

[Link](packet, this, [Link]);
[Link] =
FeatureFlags.FEATURE_MANAGER.featureSetOf([Link]());
}

private <T> void loadTags(RegistryKey<? extends Registry<? extends T>>

registryKey, [Link] serialized) {
if (![Link]()) {
Registry<T> registry =
(Registry)[Link]().getOptional(r
egistryKey).orElseThrow(() -> new IllegalStateException("Unknown registry " +
registryKey));
Map<TagKey<T>, List<RegistryEntry<T>>> map = new HashMap();
[Link](map);
[Link](registryKey, registry, serialized,
map::put);
[Link](map);
}
}

public void onEndCombat(EndCombatS2CPacket packet) {

}

public void onEnterCombat(EnterCombatS2CPacket packet) {

}

public void onDeathMessage(DeathMessageS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]());
if (entity == [Link]) {
if ([Link]()) {
 [Link](new DeathScreen([Link](),
[Link]().isHardcore()));
} else {
[Link]();
}
}

public void onDifficulty(DifficultyS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link]());
[Link]([Link]());
}

public void onSetCameraEntity(SetCameraEntityS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]);
if (entity != null) {
[Link](entity);
}

public void onWorldBorderInitialize(WorldBorderInitializeS2CPacket packet) {

[Link](packet, this, [Link]);
WorldBorder worldBorder = [Link]();
[Link]([Link](), [Link]());
long l = [Link]();
if (l > 0L) {
[Link]([Link](),
[Link](), l);
} else {
[Link]([Link]());
}

[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
}

public void onWorldBorderCenterChanged(WorldBorderCenterChangedS2CPacket

packet) {
[Link](packet, this, [Link]);
[Link]().setCenter([Link](),
[Link]());
}

public void onWorldBorderInterpolateSize(WorldBorderInterpolateSizeS2CPacket

packet) {
[Link](packet, this, [Link]);
[Link]().interpolateSize([Link](),
[Link](), [Link]());
}

public void onWorldBorderSizeChanged(WorldBorderSizeChangedS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]().setSize([Link]());
}
 public void
onWorldBorderWarningBlocksChanged(WorldBorderWarningBlocksChangedS2CPacket packet)
{
[Link](packet, this, [Link]);
[Link]().setWarningBlocks([Link]());
}

public void
onWorldBorderWarningTimeChanged(WorldBorderWarningTimeChangedS2CPacket packet) {
[Link](packet, this, [Link]);
[Link]().setWarningTime([Link]());
}

public void onTitleClear(ClearTitleS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]();
if ([Link]()) {
[Link]();
}

public void onServerMetadata(ServerMetadataS2CPacket packet) {

[Link](packet, this, [Link]);
if ([Link] != null) {
[Link] = [Link]();
Optional var10000 = [Link]();
ServerInfo var10001 = [Link];
[Link](var10001);
[Link](var10001::setFavicon);
[Link]([Link]());
[Link]([Link]);
if (![Link]()) {
SystemToast systemToast = [Link]([Link],
Type.UNSECURE_SERVER_WARNING, UNSECURE_SERVER_TOAST_TITLE,
UNSECURE_SERVER_TOAST_TEXT);
[Link]().add(systemToast);
}

}
}

public void onChatSuggestions(ChatSuggestionsS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link](), [Link]());
}

public void onOverlayMessage(OverlayMessageS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link](), false);
}

public void onTitle(TitleS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link]());
}

public void onSubtitle(SubtitleS2CPacket packet) {

 [Link](packet, this, [Link]);
[Link]([Link]());
}

public void onTitleFade(TitleFadeS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link](),
[Link](), [Link]());
}

public void onPlayerListHeader(PlayerListHeaderS2CPacket packet) {

[Link](packet, this, [Link]);

[Link]().setHeader([Link]().getString().i
sEmpty() ? null : [Link]());

[Link]().setFooter([Link]().getString().i
sEmpty() ? null : [Link]());
}

public void onRemoveEntityStatusEffect(RemoveEntityStatusEffectS2CPacket

packet) {
[Link](packet, this, [Link]);
Entity entity = [Link]([Link]);
if (entity instanceof LivingEntity) {

((LivingEntity)entity).removeStatusEffectInternal([Link]());
}

public void onPlayerRemove(PlayerRemoveS2CPacket packet) {

[Link](packet, this, [Link]);

for(UUID uUID : [Link]()) {

[Link]().setPlayerOffline(uUID);
PlayerListEntry playerListEntry =
(PlayerListEntry)[Link](uUID);
if (playerListEntry != null) {
[Link](playerListEntry);
}
}

public void onPlayerList(PlayerListS2CPacket packet) {

[Link](packet, this, [Link]);

for([Link] entry : [Link]()) {

PlayerListEntry playerListEntry = new PlayerListEntry([Link](),
[Link]());
if ([Link]([Link](),
playerListEntry) == null) {

[Link]().setPlayerOnline(playerListEntry);
}
}

for([Link] entry : [Link]()) {

 PlayerListEntry playerListEntry =
(PlayerListEntry)[Link]([Link]());
if (playerListEntry == null) {
[Link]("Ignoring player info update for unknown player {}",
[Link]());
} else {
for([Link] action : [Link]()) {
[Link](action, entry, playerListEntry);
}
}
}

private void handlePlayerListAction([Link] action,

[Link] receivedEntry, PlayerListEntry currentEntry) {
switch (action) {
case INITIALIZE_CHAT:
[Link](receivedEntry, currentEntry);
break;
case UPDATE_GAME_MODE:
if ([Link]() != [Link]() &&
[Link] != null &&
[Link]().equals([Link]())) {
[Link]([Link]());
}

[Link]([Link]());
break;
case UPDATE_LISTED:
if ([Link]()) {
[Link](currentEntry);
} else {
[Link](currentEntry);
}
break;
case UPDATE_LATENCY:
[Link]([Link]());
break;
case UPDATE_DISPLAY_NAME:
[Link]([Link]());
}

private void setPublicSession([Link] receivedEntry,

PlayerListEntry currentEntry) {
GameProfile gameProfile = [Link]();
SignatureVerifier signatureVerifier =
[Link]();
if (signatureVerifier == null) {
[Link]("Ignoring chat session from {} due to missing Services
public key", [Link]());
[Link]([Link]());
} else {
[Link] serialized =
[Link]();
if (serialized != null) {
try {
 PublicPlayerSession publicPlayerSession =
[Link](gameProfile, signatureVerifier,
PlayerPublicKey.EXPIRATION_GRACE_PERIOD);
[Link](publicPlayerSession);
} catch ([Link] publicKeyException) {
[Link]("Failed to validate profile key for player: '{}'",
[Link](), publicKeyException);
[Link]([Link]());
}
} else {
[Link]([Link]());
}

}
}

private boolean isSecureChatEnforced() {

return [Link] != null && [Link]();
}

public void onKeepAlive(KeepAliveS2CPacket packet) {

[Link](new KeepAliveC2SPacket([Link]()), () -> !
[Link](), [Link](1L));
}

private void sendPacket(Packet<ServerPlayPacketListener> packet,

BooleanSupplier sendCondition, Duration expirationTime) {
if ([Link]()) {
[Link](packet);
} else {
[Link](new QueuedPacket(packet, sendCondition,
[Link]() + [Link]()));
}

private void tickQueuedPackets() {

Iterator<QueuedPacket> iterator = [Link]();

while([Link]()) {
QueuedPacket queuedPacket = (QueuedPacket)[Link]();
if ([Link]().getAsBoolean()) {
[Link]([Link]);
[Link]();
} else if ([Link]() <= [Link]())
{
[Link]();
}
}

public void onPlayerAbilities(PlayerAbilitiesS2CPacket packet) {

[Link](packet, this, [Link]);
PlayerEntity playerEntity = [Link];
[Link]().flying = [Link]();
[Link]().creativeMode = [Link]();
[Link]().invulnerable = [Link]();
[Link]().allowFlying = [Link]();
 [Link]().setFlySpeed([Link]());
[Link]().setWalkSpeed([Link]());
}

public void onPlaySound(PlaySoundS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link], [Link](),
[Link](), [Link](), [Link](), [Link](),
[Link](), [Link](), [Link]());
}

public void onPlaySoundFromEntity(PlaySoundFromEntityS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]());
if (entity != null) {
[Link]([Link], entity,
[Link](), [Link](), [Link](), [Link](),
[Link]());
}
}

public void onResourcePackSend(ResourcePackSendS2CPacket packet) {

URL uRL = resolveUrl([Link]());
if (uRL == null) {
[Link](Status.FAILED_DOWNLOAD);
} else {
String string = packet.getSHA1();
boolean bl = [Link]();
if ([Link] != null && [Link]()
== [Link]) {
[Link]([Link]);

[Link]([Link]().download(uRL
, string, true));
} else if ([Link] != null &&
[Link]() != [Link] && (!bl ||
[Link]() != [Link])) {
[Link]([Link]);
if (bl) {

[Link]([Link]("[Link]
connect"));
}
} else {
[Link](() -> [Link](new
ConfirmScreen((enabled) -> {
[Link]((Screen)null);
if (enabled) {
if ([Link] != null) {

[Link]([Link]);
}

[Link]([Link]);

[Link]([Link]().download(uRL
, string, true));
} else {
[Link]([Link]);
 if (bl) {

[Link]([Link]("[Link]
connect"));
} else if ([Link] != null) {

[Link]([Link]);
}
}

if ([Link] != null) {
[Link]([Link]);
}

}, bl ?
[Link]("[Link].line1") :
[Link]("[Link].line1"),
getServerResourcePackPrompt(bl ?
[Link]("[Link].line2").formatted(new
Formatting[]{[Link], [Link]}) :
[Link]("[Link].line2"), [Link]()), bl ?
[Link] : [Link], (Text)(bl ?
[Link]("[Link]") : [Link]))));
}

}
}

private static Text getServerResourcePackPrompt(Text defaultPrompt, @Nullable

Text customPrompt) {
return (Text)(customPrompt == null ? defaultPrompt :
[Link]("[Link]", new Object[]
{defaultPrompt, customPrompt}));
}

@Nullable
private static URL resolveUrl(String url) {
try {
URL uRL = new URL(url);
String string = [Link]();
return !"http".equals(string) && !"https".equals(string) ? null : uRL;
} catch (MalformedURLException var3) {
return null;
}
}

private void feedbackAfterDownload(CompletableFuture<?> downloadFuture) {

[Link](() ->
[Link](Status.SUCCESSFULLY_LOADED)).exceptionally((throwable)
-> {
[Link](Status.FAILED_DOWNLOAD);
return null;
});
}

private void sendResourcePackStatus([Link]

packStatus) {
[Link](new ResourcePackStatusC2SPacket(packStatus));
}
 public void onBossBar(BossBarS2CPacket packet) {
[Link](packet, this, [Link]);
[Link]().handlePacket(packet);
}

public void onCooldownUpdate(CooldownUpdateS2CPacket packet) {

[Link](packet, this, [Link]);
if ([Link]() == 0) {
[Link]().remove([Link]());
} else {
[Link]().set([Link](),
[Link]());
}

public void onVehicleMove(VehicleMoveS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]();
if (entity != [Link] &&
[Link]()) {
[Link]([Link](), [Link](),
[Link](), [Link](), [Link]());
[Link](new VehicleMoveC2SPacket(entity));
}

public void onOpenWrittenBook(OpenWrittenBookS2CPacket packet) {

[Link](packet, this, [Link]);
ItemStack itemStack = [Link]([Link]());
if ([Link](Items.WRITTEN_BOOK)) {
[Link](new BookScreen(new
[Link](itemStack)));
}

public void onCustomPayload(CustomPayloadS2CPacket packet) {

[Link](packet, this, [Link]);
Identifier identifier = [Link]();
PacketByteBuf packetByteBuf = null;

try {
packetByteBuf = [Link]();
if ([Link](identifier)) {
String string = [Link]();
[Link](string);
[Link](string);
} else if (CustomPayloadS2CPacket.DEBUG_PATH.equals(identifier)) {
int i = [Link]();
float f = [Link]();
Path path = [Link](packetByteBuf);
[Link](i, path,
f);
} else if
(CustomPayloadS2CPacket.DEBUG_NEIGHBORS_UPDATE.equals(identifier)) {
long l = [Link]();
 BlockPos blockPos = [Link]();

((NeighborUpdateDebugRenderer)[Link]
).addNeighborUpdate(l, blockPos);
} else if (CustomPayloadS2CPacket.DEBUG_STRUCTURES.equals(identifier))
{
DimensionType dimensionType =
(DimensionType)[Link]().get(Regi
stryKeys.DIMENSION_TYPE).get([Link]());
BlockBox blockBox = new BlockBox([Link](),
[Link](), [Link](), [Link](),
[Link](), [Link]());
int j = [Link]();
List<BlockBox> list = [Link]();
List<Boolean> list2 = [Link]();

for(int k = 0; k < j; ++k) {

[Link](new BlockBox([Link](),
[Link](), [Link](), [Link](),
[Link](), [Link]()));
[Link]([Link]());
}

[Link](blockBox, list,
list2, dimensionType);
} else if
(CustomPayloadS2CPacket.DEBUG_WORLDGEN_ATTEMPT.equals(identifier)) {

((WorldGenAttemptDebugRenderer)[Link]
er).addBox([Link](), [Link](),
[Link](), [Link](), [Link](),
[Link]());
} else if
(CustomPayloadS2CPacket.DEBUG_VILLAGE_SECTIONS.equals(identifier)) {
int i = [Link]();

for(int m = 0; m < i; ++m) {

[Link]([Link]
dChunkSectionPos());
}

int m = [Link]();

for(int j = 0; j < m; ++j) {

[Link](packetByteBuf.
readChunkSectionPos());
}
} else if (CustomPayloadS2CPacket.DEBUG_POI_ADDED.equals(identifier)) {
BlockPos blockPos2 = [Link]();
String string2 = [Link]();
int j = [Link]();
[Link] pointOfInterest = new
[Link](blockPos2, string2, j);

[Link](pointOfInterest);
} else if (CustomPayloadS2CPacket.DEBUG_POI_REMOVED.equals(identifier))
{
BlockPos blockPos2 = [Link]();

[Link](blockPos2);
} else if
(CustomPayloadS2CPacket.DEBUG_POI_TICKET_COUNT.equals(identifier)) {
BlockPos blockPos2 = [Link]();
int m = [Link]();

[Link](blockPos2, m);
} else if
(CustomPayloadS2CPacket.DEBUG_GOAL_SELECTOR.equals(identifier)) {
BlockPos blockPos2 = [Link]();
int m = [Link]();
int j = [Link]();
List<[Link]> list =
[Link]();

for(int n = 0; n < j; ++n) {

int k = [Link]();
boolean bl = [Link]();
String string3 = [Link](255);
[Link](new [Link](blockPos2,
k, string3, bl));
}

[Link](m, list);
} else if (CustomPayloadS2CPacket.DEBUG_RAIDS.equals(identifier)) {
int i = [Link]();
Collection<BlockPos> collection = [Link]();

for(int j = 0; j < i; ++j) {

[Link]([Link]());
}

[Link](collection);
} else if (CustomPayloadS2CPacket.DEBUG_BRAIN.equals(identifier)) {
double d = [Link]();
double e = [Link]();
double g = [Link]();
Position position = new PositionImpl(d, e, g);
UUID uUID = [Link]();
int o = [Link]();
String string4 = [Link]();
String string5 = [Link]();
int p = [Link]();
float h = [Link]();
float q = [Link]();
String string6 = [Link]();
Path path2 = (Path)[Link](Path::fromBuffer);
boolean bl2 = [Link]();
int r = [Link]();
[Link] brain = new
[Link](uUID, o, string4, string5, p, h, q, position, string6,
path2, bl2, r);
int s = [Link]();
 for(int t = 0; t < s; ++t) {
String string7 = [Link]();
[Link](string7);
}

int t = [Link]();

for(int u = 0; u < t; ++u) {

String string8 = [Link]();
[Link](string8);
}

int u = [Link]();

for(int v = 0; v < u; ++v) {

String string9 = [Link]();
[Link](string9);
}

int v = [Link]();

for(int w = 0; w < v; ++w) {

BlockPos blockPos3 = [Link]();
[Link](blockPos3);
}

int w = [Link]();

for(int x = 0; x < w; ++x) {

BlockPos blockPos4 = [Link]();
[Link](blockPos4);
}

int x = [Link]();

for(int y = 0; y < x; ++y) {

String string10 = [Link]();
[Link](string10);
}

[Link](brain);
} else if (CustomPayloadS2CPacket.DEBUG_BEE.equals(identifier)) {
double d = [Link]();
double e = [Link]();
double g = [Link]();
Position position = new PositionImpl(d, e, g);
UUID uUID = [Link]();
int o = [Link]();
BlockPos blockPos5 =
(BlockPos)[Link](PacketByteBuf::readBlockPos);
BlockPos blockPos6 =
(BlockPos)[Link](PacketByteBuf::readBlockPos);
int p = [Link]();
Path path3 = (Path)[Link](Path::fromBuffer);
[Link] bee = new [Link](uUID, o,
position, path3, blockPos5, blockPos6, p);
int z = [Link]();

for(int aa = 0; aa < z; ++aa) {

 String string11 = [Link]();
[Link](string11);
}

int aa = [Link]();

for(int ab = 0; ab < aa; ++ab) {

BlockPos blockPos7 = [Link]();
[Link](blockPos7);
}

[Link](bee);
} else if (CustomPayloadS2CPacket.DEBUG_HIVE.equals(identifier)) {
BlockPos blockPos2 = [Link]();
String string2 = [Link]();
int j = [Link]();
int ac = [Link]();
boolean bl3 = [Link]();
[Link] hive = new [Link](blockPos2,
string2, j, ac, bl3, [Link]());
[Link](hive);
} else if
(CustomPayloadS2CPacket.DEBUG_GAME_TEST_CLEAR.equals(identifier)) {
[Link]();
} else if
(CustomPayloadS2CPacket.DEBUG_GAME_TEST_ADD_MARKER.equals(identifier)) {
BlockPos blockPos2 = [Link]();
int m = [Link]();
String string12 = [Link]();
int ac = [Link]();

[Link](blockPos2, m, string12,
ac);
} else if (CustomPayloadS2CPacket.DEBUG_GAME_EVENT.equals(identifier))
{
GameEvent gameEvent = (GameEvent)Registries.GAME_EVENT.get(new
Identifier([Link]()));
Vec3d vec3d = new Vec3d([Link](),
[Link](), [Link]());

[Link](gameEvent, vec3d);
} else if
(CustomPayloadS2CPacket.DEBUG_GAME_EVENT_LISTENERS.equals(identifier)) {
Identifier identifier2 = [Link]();
PositionSource positionSource =
((PositionSourceType)Registries.POSITION_SOURCE_TYPE.getOrEmpty(identifier2).orElse
Throw(() -> new IllegalArgumentException("Unknown position source type " +
identifier2))).readFromBuf(packetByteBuf);
int j = [Link]();

[Link](positionSource, j);
} else {
[Link]("Unknown custom packed identifier: {}", identifier);
}
} finally {
if (packetByteBuf != null) {
[Link]();
}
 }

public void onScoreboardObjectiveUpdate(ScoreboardObjectiveUpdateS2CPacket

packet) {
[Link](packet, this, [Link]);
Scoreboard scoreboard = [Link]();
String string = [Link]();
if ([Link]() == 0) {
[Link](string, [Link],
[Link](), [Link]());
} else if ([Link](string)) {
ScoreboardObjective scoreboardObjective =
[Link](string);
if ([Link]() == 1) {
[Link](scoreboardObjective);
} else if ([Link]() == 2) {
[Link]([Link]());
[Link]([Link]());
}
}

public void onScoreboardPlayerUpdate(ScoreboardPlayerUpdateS2CPacket packet) {

[Link](packet, this, [Link]);
Scoreboard scoreboard = [Link]();
String string = [Link]();
switch ([Link]()) {
case CHANGE:
ScoreboardObjective scoreboardObjective =
[Link](string);
ScoreboardPlayerScore scoreboardPlayerScore =
[Link]([Link](), scoreboardObjective);
[Link]([Link]());
break;
case REMOVE:
[Link]([Link](),
[Link](string));
}

public void onScoreboardDisplay(ScoreboardDisplayS2CPacket packet) {

[Link](packet, this, [Link]);
Scoreboard scoreboard = [Link]();
String string = [Link]();
ScoreboardObjective scoreboardObjective = string == null ? null :
[Link](string);
[Link]([Link](), scoreboardObjective);
}

public void onTeam(TeamS2CPacket packet) {

[Link](packet, this, [Link]);
Scoreboard scoreboard = [Link]();
[Link] operation = [Link]();
Team team;
if (operation == [Link]) {
 team = [Link]([Link]());
} else {
team = [Link]([Link]());
if (team == null) {
[Link]("Received packet for unknown team {}: team action: {},
player action: {}", new Object[]{[Link](), [Link](),
[Link]()});
return;
}
}

Optional<[Link]> optional = [Link]();

[Link]((teamx) -> {
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link] visibilityRule =
[Link]([Link]());
if (visibilityRule != null) {
[Link](visibilityRule);
}

[Link] collisionRule =
[Link]([Link]());
if (collisionRule != null) {
[Link](collisionRule);
}

[Link]([Link]());
[Link]([Link]());
});
[Link] operation2 = [Link]();
if (operation2 == [Link]) {
for(String string : [Link]()) {
[Link](string, team);
}
} else if (operation2 == [Link]) {
for(String string : [Link]()) {
[Link](string, team);
}
}

if (operation == [Link]) {
[Link](team);
}

public void onParticle(ParticleS2CPacket packet) {

[Link](packet, this, [Link]);
if ([Link]() == 0) {
double d = (double)([Link]() * [Link]());
double e = (double)([Link]() * [Link]());
double f = (double)([Link]() * [Link]());

try {
[Link]([Link](),
[Link](), [Link](), [Link](), [Link](), d, e, f);
} catch (Throwable var17) {
 [Link]("Could not spawn particle effect {}",
[Link]());
}
} else {
for(int i = 0; i < [Link](); ++i) {
double g = [Link]() *
(double)[Link]();
double h = [Link]() *
(double)[Link]();
double j = [Link]() *
(double)[Link]();
double k = [Link]() * (double)[Link]();
double l = [Link]() * (double)[Link]();
double m = [Link]() * (double)[Link]();

try {
[Link]([Link](),
[Link](), [Link]() + g, [Link]() + h, [Link]() + j,
k, l, m);
} catch (Throwable var16) {
[Link]("Could not spawn particle effect {}",
[Link]());
return;
}
}
}

public void onPing(PlayPingS2CPacket packet) {

[Link](packet, this, [Link]);
[Link](new PlayPongC2SPacket([Link]()));
}

public void onEntityAttributes(EntityAttributesS2CPacket packet) {

[Link](packet, this, [Link]);
Entity entity = [Link]([Link]());
if (entity != null) {
if (!(entity instanceof LivingEntity)) {
throw new IllegalStateException("Server tried to update attributes
of a non-living entity (actually: " + entity + ")");
} else {
AttributeContainer attributeContainer =
((LivingEntity)entity).getAttributes();

for([Link] entry : [Link]()) {

EntityAttributeInstance entityAttributeInstance =
[Link]([Link]());
if (entityAttributeInstance == null) {
[Link]("Entity {} does not have attribute {}", entity,
[Link]([Link]()));
} else {
[Link]([Link]());
[Link]();

for(EntityAttributeModifier entityAttributeModifier :
[Link]()) {

[Link](entityAttributeModifier);
 }
}
}

}
}
}

public void onCraftFailedResponse(CraftFailedResponseS2CPacket packet) {

[Link](packet, this, [Link]);
ScreenHandler screenHandler = [Link];
if ([Link] == [Link]()) {
[Link]([Link]()).ifPresent((recipe) -> {
if ([Link] instanceof RecipeBookProvider) {
RecipeBookWidget recipeBookWidget =
((RecipeBookProvider)[Link]).getRecipeBookWidget();
[Link](recipe, [Link]);
}

});
}
}

public void onLightUpdate(LightUpdateS2CPacket packet) {

[Link](packet, this, [Link]);
int i = [Link]();
int j = [Link]();
LightData lightData = [Link]();
[Link](() -> [Link](i, j, lightData));
}

private void readLightData(int x, int z, LightData data) {

LightingProvider lightingProvider =
[Link]().getLightingProvider();
BitSet bitSet = [Link]();
BitSet bitSet2 = [Link]();
Iterator<byte[]> iterator = [Link]().iterator();
[Link](x, z, lightingProvider, [Link], bitSet, bitSet2,
iterator);
BitSet bitSet3 = [Link]();
BitSet bitSet4 = [Link]();
Iterator<byte[]> iterator2 = [Link]().iterator();
[Link](x, z, lightingProvider, [Link], bitSet3,
bitSet4, iterator2);
[Link](new ChunkPos(x, z), true);
}

public void onSetTradeOffers(SetTradeOffersS2CPacket packet) {

[Link](packet, this, [Link]);
ScreenHandler screenHandler = [Link];
if ([Link]() == [Link] && screenHandler instanceof
MerchantScreenHandler merchantScreenHandler) {
[Link](new
TradeOfferList([Link]().toNbt()));
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
}
 }

public void onChunkLoadDistance(ChunkLoadDistanceS2CPacket packet) {

[Link](packet, this, [Link]);
[Link] = [Link]();
[Link]([Link]);
[Link]().updateLoadDistance([Link]());
}

public void onSimulationDistance(SimulationDistanceS2CPacket packet) {

[Link](packet, this, [Link]);
[Link] = [Link]();
[Link]([Link]);
}

public void onChunkRenderDistanceCenter(ChunkRenderDistanceCenterS2CPacket

packet) {
[Link](packet, this, [Link]);
[Link]().setChunkMapCenter([Link](),
[Link]());
}

public void onPlayerActionResponse(PlayerActionResponseS2CPacket packet) {

[Link](packet, this, [Link]);
[Link]([Link]());
}

public void onBundle(BundleS2CPacket packet) {

[Link](packet, this, [Link]);

for(Packet<ClientPlayPacketListener> packet2 : [Link]()) {

[Link](this);
}

private void updateLighting(int chunkX, int chunkZ, LightingProvider provider,

LightType type, BitSet inited, BitSet uninited, Iterator<byte[]> nibbles) {
for(int i = 0; i < [Link](); ++i) {
int j = [Link]() + i;
boolean bl = [Link](i);
boolean bl2 = [Link](i);
if (bl || bl2) {
[Link](type, [Link](chunkX, j,
chunkZ), bl ? new ChunkNibbleArray((byte[])((byte[])[Link]()).clone()) : new
ChunkNibbleArray());
[Link](chunkX, j, chunkZ);
}
}

public ClientConnection getConnection() {

return [Link];
}

public boolean isConnectionOpen() {

return [Link]();
}

public Collection<PlayerListEntry> getListedPlayerListEntries() {

return [Link];
}

public Collection<PlayerListEntry> getPlayerList() {

return [Link]();
}

public Collection<UUID> getPlayerUuids() {

return [Link]();
}

@Nullable
public PlayerListEntry getPlayerListEntry(UUID uuid) {
return (PlayerListEntry)[Link](uuid);
}

@Nullable
public PlayerListEntry getPlayerListEntry(String profileName) {
for(PlayerListEntry playerListEntry : [Link]()) {
if ([Link]().getName().equals(profileName)) {
return playerListEntry;
}
}

return null;
}

public GameProfile getProfile() {

return [Link];
}

public ClientAdvancementManager getAdvancementHandler() {

return [Link];
}

public CommandDispatcher<CommandSource> getCommandDispatcher() {

return [Link];
}

public ClientWorld getWorld() {

return [Link];
}

public DataQueryHandler getDataQueryHandler() {

return [Link];
}

public UUID getSessionId() {

return [Link];
}

public Set<RegistryKey<World>> getWorldKeys() {

return [Link];
}

public DynamicRegistryManager getRegistryManager() {

 return [Link]();
}

public void acknowledge(SignedMessage message, boolean displayed) {

MessageSignatureData messageSignatureData = [Link]();
if (messageSignatureData != null &&
[Link](messageSignatureData, displayed) &&
[Link]() > 64) {
[Link]();
}

private void sendAcknowledgment() {

int i = [Link]();
if (i > 0) {
[Link](new MessageAcknowledgmentC2SPacket(i));
}

public void sendChatMessage(String content) {

Instant instant = [Link]();
long l = [Link]();
[Link] lastSeenMessages =
[Link]();
MessageSignatureData messageSignatureData = [Link](new
MessageBody(content, instant, l, [Link]()));
[Link](new ChatMessageC2SPacket(content, instant, l,
messageSignatureData, [Link]()));
}

public void sendChatCommand(String command) {

Instant instant = [Link]();
long l = [Link]();
[Link] lastSeenMessages =
[Link]();
ArgumentSignatureDataMap argumentSignatureDataMap =
[Link]([Link]([Link](command)), (value) -
> {
MessageBody messageBody = new MessageBody(value, instant, l,
[Link]());
return [Link](messageBody);
});
[Link](new CommandExecutionC2SPacket(command, instant, l,
argumentSignatureDataMap, [Link]()));
}

public boolean sendCommand(String command) {

if ([Link]([Link](command)).arguments().isEmpty()) {
[Link] lastSeenMessages =
[Link]();
[Link](new CommandExecutionC2SPacket(command, [Link](),
0L, [Link], [Link]()));
return true;
} else {
return false;
}
}
 private ParseResults<CommandSource> parse(String command) {
return [Link](command, [Link]);
}

public void tick() {

if ([Link]()) {
ProfileKeys profileKeys = [Link]();
if ([Link]()) {
[Link]().thenAcceptAsync((keyPair) ->
[Link](this::updateKeyPair), [Link]);
}
}

[Link]();
[Link]();
}

public void updateKeyPair(PlayerKeyPair keyPair) {

if ([Link]().equals([Link]().getUuidOrNull()))
{
if ([Link] == null || ![Link]().equals(keyPair)) {
[Link] = [Link](keyPair);
[Link] =
[Link]([Link]());
[Link](new
PlayerSessionC2SPacket([Link]().toSerialized()));
}
}
}

@Nullable
public ServerInfo getServerInfo() {
return [Link];
}

public FeatureSet getEnabledFeatures() {

return [Link];
}

public boolean hasFeature(FeatureSet feature) {

return [Link]([Link]());
}

@Environment([Link])
static record QueuedPacket(Packet<ServerPlayPacketListener> packet,
BooleanSupplier sendCondition, long expirationTime) {
final Packet<ServerPlayPacketListener> packet;
}
}