1269 lines
No EOL
53 KiB
Java
Executable file
1269 lines
No EOL
53 KiB
Java
Executable file
package net.minecraft.network;
|
|
|
|
import com.google.common.collect.Lists;
|
|
import com.google.common.primitives.Doubles;
|
|
import com.google.common.primitives.Floats;
|
|
import net.lax1dude.eaglercraft.v1_8.netty.Unpooled;
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import java.util.concurrent.Callable;
|
|
|
|
import net.lax1dude.eaglercraft.v1_8.sp.server.EaglerMinecraftServer;
|
|
import net.minecraft.block.material.Material;
|
|
import net.minecraft.command.server.CommandBlockLogic;
|
|
import net.minecraft.crash.CrashReport;
|
|
import net.minecraft.crash.CrashReportCategory;
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.EntityMinecartCommandBlock;
|
|
import net.minecraft.entity.item.EntityItem;
|
|
import net.minecraft.entity.item.EntityXPOrb;
|
|
import net.minecraft.entity.passive.EntityHorse;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.entity.player.EntityPlayerMP;
|
|
import net.minecraft.entity.player.InventoryPlayer;
|
|
import net.minecraft.entity.projectile.EntityArrow;
|
|
import net.minecraft.init.Items;
|
|
import net.minecraft.inventory.Container;
|
|
import net.minecraft.inventory.ContainerBeacon;
|
|
import net.minecraft.inventory.ContainerMerchant;
|
|
import net.minecraft.inventory.ContainerRepair;
|
|
import net.minecraft.inventory.IInventory;
|
|
import net.minecraft.inventory.Slot;
|
|
import net.minecraft.item.ItemEditableBook;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.item.ItemWritableBook;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.nbt.NBTTagString;
|
|
import net.minecraft.network.play.INetHandlerPlayServer;
|
|
import net.minecraft.network.play.client.C00PacketKeepAlive;
|
|
import net.minecraft.network.play.client.C01PacketChatMessage;
|
|
import net.minecraft.network.play.client.C02PacketUseEntity;
|
|
import net.minecraft.network.play.client.C03PacketPlayer;
|
|
import net.minecraft.network.play.client.C07PacketPlayerDigging;
|
|
import net.minecraft.network.play.client.C08PacketPlayerBlockPlacement;
|
|
import net.minecraft.network.play.client.C09PacketHeldItemChange;
|
|
import net.minecraft.network.play.client.C0APacketAnimation;
|
|
import net.minecraft.network.play.client.C0BPacketEntityAction;
|
|
import net.minecraft.network.play.client.C0CPacketInput;
|
|
import net.minecraft.network.play.client.C0DPacketCloseWindow;
|
|
import net.minecraft.network.play.client.C0EPacketClickWindow;
|
|
import net.minecraft.network.play.client.C0FPacketConfirmTransaction;
|
|
import net.minecraft.network.play.client.C10PacketCreativeInventoryAction;
|
|
import net.minecraft.network.play.client.C11PacketEnchantItem;
|
|
import net.minecraft.network.play.client.C12PacketUpdateSign;
|
|
import net.minecraft.network.play.client.C13PacketPlayerAbilities;
|
|
import net.minecraft.network.play.client.C14PacketTabComplete;
|
|
import net.minecraft.network.play.client.C15PacketClientSettings;
|
|
import net.minecraft.network.play.client.C16PacketClientStatus;
|
|
import net.minecraft.network.play.client.C17PacketCustomPayload;
|
|
import net.minecraft.network.play.client.C18PacketSpectate;
|
|
import net.minecraft.network.play.client.C19PacketResourcePackStatus;
|
|
import net.minecraft.network.play.server.S00PacketKeepAlive;
|
|
import net.minecraft.network.play.server.S02PacketChat;
|
|
import net.minecraft.network.play.server.S07PacketRespawn;
|
|
import net.minecraft.network.play.server.S08PacketPlayerPosLook;
|
|
import net.minecraft.network.play.server.S18PacketEntityTeleport;
|
|
import net.minecraft.network.play.server.S23PacketBlockChange;
|
|
import net.minecraft.network.play.server.S2FPacketSetSlot;
|
|
import net.minecraft.network.play.server.S32PacketConfirmTransaction;
|
|
import net.minecraft.network.play.server.S3APacketTabComplete;
|
|
import net.minecraft.network.play.server.S3FPacketCustomPayload;
|
|
import net.minecraft.network.play.server.S40PacketDisconnect;
|
|
import net.minecraft.server.MinecraftServer;
|
|
import net.minecraft.stats.AchievementList;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.tileentity.TileEntityCommandBlock;
|
|
import net.minecraft.tileentity.TileEntitySign;
|
|
import net.minecraft.util.AxisAlignedBB;
|
|
import net.minecraft.util.BlockPos;
|
|
import net.minecraft.util.ChatAllowedCharacters;
|
|
import net.minecraft.util.ChatComponentText;
|
|
import net.minecraft.util.ChatComponentTranslation;
|
|
import net.minecraft.util.EnumChatFormatting;
|
|
import net.minecraft.util.EnumFacing;
|
|
import net.minecraft.util.IChatComponent;
|
|
import net.minecraft.util.ITickable;
|
|
import net.minecraft.util.IntHashMap;
|
|
import net.minecraft.util.ReportedException;
|
|
import net.minecraft.world.WorldServer;
|
|
import net.lax1dude.eaglercraft.v1_8.sp.server.socket.IntegratedServerPlayerNetworkManager;
|
|
import net.lax1dude.eaglercraft.v1_8.sp.server.voice.IntegratedVoiceService;
|
|
|
|
import org.apache.commons.lang3.StringUtils;
|
|
import net.lax1dude.eaglercraft.v1_8.log4j.LogManager;
|
|
import net.lax1dude.eaglercraft.v1_8.log4j.Logger;
|
|
|
|
/**+
|
|
* This portion of EaglercraftX contains deobfuscated Minecraft 1.8 source code.
|
|
*
|
|
* Minecraft 1.8.8 bytecode is (c) 2015 Mojang AB. "Do not distribute!"
|
|
* Mod Coder Pack v9.18 deobfuscation configs are (c) Copyright by the MCP Team
|
|
*
|
|
* EaglercraftX 1.8 patch files (c) 2022-2024 lax1dude, ayunami2000. All Rights Reserved.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
|
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
public class NetHandlerPlayServer implements INetHandlerPlayServer, ITickable {
|
|
|
|
private static final Logger logger = LogManager.getLogger();
|
|
public final IntegratedServerPlayerNetworkManager netManager;
|
|
private final MinecraftServer serverController;
|
|
public EntityPlayerMP playerEntity;
|
|
private int networkTickCount;
|
|
private int field_175090_f;
|
|
private int floatingTickCount;
|
|
private boolean field_147366_g;
|
|
private int field_147378_h;
|
|
private long lastPingTime;
|
|
private long lastSentPingPacket;
|
|
private int chatSpamThresholdCount;
|
|
private int itemDropThreshold;
|
|
private IntHashMap<Short> field_147372_n = new IntHashMap();
|
|
private double lastPosX;
|
|
private double lastPosY;
|
|
private double lastPosZ;
|
|
private boolean hasMoved = true;
|
|
private boolean hasDisconnected = false;
|
|
|
|
public NetHandlerPlayServer(MinecraftServer server, IntegratedServerPlayerNetworkManager networkManagerIn,
|
|
EntityPlayerMP playerIn) {
|
|
this.serverController = server;
|
|
this.netManager = networkManagerIn;
|
|
networkManagerIn.setNetHandler(this);
|
|
this.playerEntity = playerIn;
|
|
playerIn.playerNetServerHandler = this;
|
|
}
|
|
|
|
/**+
|
|
* Like the old updateEntity(), except more generic.
|
|
*/
|
|
public void update() {
|
|
this.field_147366_g = false;
|
|
++this.networkTickCount;
|
|
this.serverController.theProfiler.startSection("keepAlive");
|
|
if ((long) this.networkTickCount - this.lastSentPingPacket > 40L) {
|
|
this.lastSentPingPacket = (long) this.networkTickCount;
|
|
this.lastPingTime = this.currentTimeMillis();
|
|
this.field_147378_h = (int) this.lastPingTime;
|
|
this.sendPacket(new S00PacketKeepAlive(this.field_147378_h));
|
|
}
|
|
|
|
this.serverController.theProfiler.endSection();
|
|
if (this.chatSpamThresholdCount > 0) {
|
|
--this.chatSpamThresholdCount;
|
|
}
|
|
|
|
if (this.itemDropThreshold > 0) {
|
|
--this.itemDropThreshold;
|
|
}
|
|
|
|
if (this.playerEntity.getLastActiveTime() > 0L && this.serverController.getMaxPlayerIdleMinutes() > 0
|
|
&& MinecraftServer.getCurrentTimeMillis() - this.playerEntity
|
|
.getLastActiveTime() > (long) (this.serverController.getMaxPlayerIdleMinutes() * 1000 * 60)) {
|
|
this.kickPlayerFromServer("You have been idle for too long!");
|
|
}
|
|
|
|
}
|
|
|
|
public IntegratedServerPlayerNetworkManager getNetworkManager() {
|
|
return this.netManager;
|
|
}
|
|
|
|
/**+
|
|
* Kick a player from the server with a reason
|
|
*/
|
|
public void kickPlayerFromServer(String reason) {
|
|
final ChatComponentText chatcomponenttext = new ChatComponentText(reason);
|
|
this.netManager.sendPacket(new S40PacketDisconnect(chatcomponenttext));
|
|
this.netManager.closeChannel(chatcomponenttext);
|
|
}
|
|
|
|
/**+
|
|
* Processes player movement input. Includes walking, strafing,
|
|
* jumping, sneaking; excludes riding and toggling
|
|
* flying/sprinting
|
|
*/
|
|
public void processInput(C0CPacketInput c0cpacketinput) {
|
|
this.playerEntity.setEntityActionState(c0cpacketinput.getStrafeSpeed(), c0cpacketinput.getForwardSpeed(),
|
|
c0cpacketinput.isJumping(), c0cpacketinput.isSneaking());
|
|
}
|
|
|
|
private boolean func_183006_b(C03PacketPlayer parC03PacketPlayer) {
|
|
return !Doubles.isFinite(parC03PacketPlayer.getPositionX())
|
|
|| !Doubles.isFinite(parC03PacketPlayer.getPositionY())
|
|
|| !Doubles.isFinite(parC03PacketPlayer.getPositionZ())
|
|
|| !Floats.isFinite(parC03PacketPlayer.getPitch()) || !Floats.isFinite(parC03PacketPlayer.getYaw());
|
|
}
|
|
|
|
/**+
|
|
* Processes clients perspective on player positioning and/or
|
|
* orientation
|
|
*/
|
|
public void processPlayer(C03PacketPlayer c03packetplayer) {
|
|
if (this.func_183006_b(c03packetplayer)) {
|
|
this.kickPlayerFromServer("Invalid move packet received");
|
|
} else {
|
|
WorldServer worldserver = this.serverController.worldServerForDimension(this.playerEntity.dimension);
|
|
this.field_147366_g = true;
|
|
if (!this.playerEntity.playerConqueredTheEnd) {
|
|
double d0 = this.playerEntity.posX;
|
|
double d1 = this.playerEntity.posY;
|
|
double d2 = this.playerEntity.posZ;
|
|
double d3 = 0.0D;
|
|
double d4 = c03packetplayer.getPositionX() - this.lastPosX;
|
|
double d5 = c03packetplayer.getPositionY() - this.lastPosY;
|
|
double d6 = c03packetplayer.getPositionZ() - this.lastPosZ;
|
|
if (c03packetplayer.isMoving()) {
|
|
d3 = d4 * d4 + d5 * d5 + d6 * d6;
|
|
if (!this.hasMoved && d3 < 0.25D) {
|
|
this.hasMoved = true;
|
|
}
|
|
}
|
|
|
|
if (this.hasMoved) {
|
|
this.field_175090_f = this.networkTickCount;
|
|
if (this.playerEntity.ridingEntity != null) {
|
|
float f4 = this.playerEntity.rotationYaw;
|
|
float f = this.playerEntity.rotationPitch;
|
|
this.playerEntity.ridingEntity.updateRiderPosition();
|
|
double d16 = this.playerEntity.posX;
|
|
double d17 = this.playerEntity.posY;
|
|
double d18 = this.playerEntity.posZ;
|
|
if (c03packetplayer.getRotating()) {
|
|
f4 = c03packetplayer.getYaw();
|
|
f = c03packetplayer.getPitch();
|
|
}
|
|
|
|
this.playerEntity.onGround = c03packetplayer.isOnGround();
|
|
this.playerEntity.onUpdateEntity();
|
|
this.playerEntity.setPositionAndRotation(d16, d17, d18, f4, f);
|
|
if (this.playerEntity.ridingEntity != null) {
|
|
this.playerEntity.ridingEntity.updateRiderPosition();
|
|
}
|
|
|
|
this.serverController.getConfigurationManager()
|
|
.serverUpdateMountedMovingPlayer(this.playerEntity);
|
|
if (this.playerEntity.ridingEntity != null) {
|
|
if (d3 > 4.0D) {
|
|
Entity entity = this.playerEntity.ridingEntity;
|
|
this.playerEntity.playerNetServerHandler
|
|
.sendPacket(new S18PacketEntityTeleport(entity));
|
|
this.setPlayerLocation(this.playerEntity.posX, this.playerEntity.posY,
|
|
this.playerEntity.posZ, this.playerEntity.rotationYaw,
|
|
this.playerEntity.rotationPitch);
|
|
}
|
|
|
|
this.playerEntity.ridingEntity.isAirBorne = true;
|
|
}
|
|
|
|
if (this.hasMoved) {
|
|
this.lastPosX = this.playerEntity.posX;
|
|
this.lastPosY = this.playerEntity.posY;
|
|
this.lastPosZ = this.playerEntity.posZ;
|
|
}
|
|
|
|
worldserver.updateEntity(this.playerEntity);
|
|
return;
|
|
}
|
|
|
|
if (this.playerEntity.isPlayerSleeping()) {
|
|
this.playerEntity.onUpdateEntity();
|
|
this.playerEntity.setPositionAndRotation(this.lastPosX, this.lastPosY, this.lastPosZ,
|
|
this.playerEntity.rotationYaw, this.playerEntity.rotationPitch);
|
|
worldserver.updateEntity(this.playerEntity);
|
|
return;
|
|
}
|
|
|
|
double d7 = this.playerEntity.posY;
|
|
this.lastPosX = this.playerEntity.posX;
|
|
this.lastPosY = this.playerEntity.posY;
|
|
this.lastPosZ = this.playerEntity.posZ;
|
|
double d8 = this.playerEntity.posX;
|
|
double d9 = this.playerEntity.posY;
|
|
double d10 = this.playerEntity.posZ;
|
|
float f1 = this.playerEntity.rotationYaw;
|
|
float f2 = this.playerEntity.rotationPitch;
|
|
if (c03packetplayer.isMoving() && c03packetplayer.getPositionY() == -999.0D) {
|
|
c03packetplayer.setMoving(false);
|
|
}
|
|
|
|
if (c03packetplayer.isMoving()) {
|
|
d8 = c03packetplayer.getPositionX();
|
|
d9 = c03packetplayer.getPositionY();
|
|
d10 = c03packetplayer.getPositionZ();
|
|
if (Math.abs(c03packetplayer.getPositionX()) > 3.0E7D
|
|
|| Math.abs(c03packetplayer.getPositionZ()) > 3.0E7D) {
|
|
this.kickPlayerFromServer("Illegal position");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (c03packetplayer.getRotating()) {
|
|
f1 = c03packetplayer.getYaw();
|
|
f2 = c03packetplayer.getPitch();
|
|
}
|
|
|
|
this.playerEntity.onUpdateEntity();
|
|
this.playerEntity.setPositionAndRotation(this.lastPosX, this.lastPosY, this.lastPosZ, f1, f2);
|
|
if (!this.hasMoved) {
|
|
return;
|
|
}
|
|
|
|
double d11 = d8 - this.playerEntity.posX;
|
|
double d12 = d9 - this.playerEntity.posY;
|
|
double d13 = d10 - this.playerEntity.posZ;
|
|
double d14 = this.playerEntity.motionX * this.playerEntity.motionX
|
|
+ this.playerEntity.motionY * this.playerEntity.motionY
|
|
+ this.playerEntity.motionZ * this.playerEntity.motionZ;
|
|
double d15 = d11 * d11 + d12 * d12 + d13 * d13;
|
|
if (d15 - d14 > 100.0D && (!this.serverController.isSinglePlayer()
|
|
|| !this.serverController.getServerOwner().equals(this.playerEntity.getName()))) {
|
|
logger.warn(this.playerEntity.getName() + " moved too quickly! " + d11 + "," + d12 + "," + d13
|
|
+ " (" + d11 + ", " + d12 + ", " + d13 + ")");
|
|
this.setPlayerLocation(this.lastPosX, this.lastPosY, this.lastPosZ,
|
|
this.playerEntity.rotationYaw, this.playerEntity.rotationPitch);
|
|
return;
|
|
}
|
|
|
|
float f3 = 0.0625F;
|
|
boolean flag = worldserver.getCollidingBoundingBoxes(this.playerEntity,
|
|
this.playerEntity.getEntityBoundingBox().contract((double) f3, (double) f3, (double) f3))
|
|
.isEmpty();
|
|
if (this.playerEntity.onGround && !c03packetplayer.isOnGround() && d12 > 0.0D) {
|
|
this.playerEntity.jump();
|
|
}
|
|
|
|
this.playerEntity.moveEntity(d11, d12, d13);
|
|
this.playerEntity.onGround = c03packetplayer.isOnGround();
|
|
d11 = d8 - this.playerEntity.posX;
|
|
d12 = d9 - this.playerEntity.posY;
|
|
if (d12 > -0.5D || d12 < 0.5D) {
|
|
d12 = 0.0D;
|
|
}
|
|
|
|
d13 = d10 - this.playerEntity.posZ;
|
|
d15 = d11 * d11 + d12 * d12 + d13 * d13;
|
|
boolean flag1 = false;
|
|
if (d15 > 0.0625D && !this.playerEntity.isPlayerSleeping()
|
|
&& !this.playerEntity.theItemInWorldManager.isCreative()) {
|
|
flag1 = true;
|
|
logger.warn(this.playerEntity.getName() + " moved wrongly!");
|
|
}
|
|
|
|
this.playerEntity.setPositionAndRotation(d8, d9, d10, f1, f2);
|
|
this.playerEntity.addMovementStat(this.playerEntity.posX - d0, this.playerEntity.posY - d1,
|
|
this.playerEntity.posZ - d2);
|
|
if (!this.playerEntity.noClip) {
|
|
boolean flag2 = worldserver.getCollidingBoundingBoxes(this.playerEntity, this.playerEntity
|
|
.getEntityBoundingBox().contract((double) f3, (double) f3, (double) f3)).isEmpty();
|
|
if (flag && (flag1 || !flag2) && !this.playerEntity.isPlayerSleeping()) {
|
|
this.setPlayerLocation(this.lastPosX, this.lastPosY, this.lastPosZ, f1, f2);
|
|
return;
|
|
}
|
|
}
|
|
|
|
AxisAlignedBB axisalignedbb = this.playerEntity.getEntityBoundingBox()
|
|
.expand((double) f3, (double) f3, (double) f3).addCoord(0.0D, -0.55D, 0.0D);
|
|
if (!this.serverController.isFlightAllowed() && !this.playerEntity.capabilities.allowFlying
|
|
&& !worldserver.checkBlockCollision(axisalignedbb)) {
|
|
if (d12 >= -0.03125D) {
|
|
++this.floatingTickCount;
|
|
if (this.floatingTickCount > 80) {
|
|
logger.warn(this.playerEntity.getName() + " was kicked for floating too long!");
|
|
this.kickPlayerFromServer("Flying is not enabled on this server");
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
this.floatingTickCount = 0;
|
|
}
|
|
|
|
this.playerEntity.onGround = c03packetplayer.isOnGround();
|
|
this.serverController.getConfigurationManager().serverUpdateMountedMovingPlayer(this.playerEntity);
|
|
this.playerEntity.handleFalling(this.playerEntity.posY - d7, c03packetplayer.isOnGround());
|
|
} else if (this.networkTickCount - this.field_175090_f > 20) {
|
|
this.setPlayerLocation(this.lastPosX, this.lastPosY, this.lastPosZ, this.playerEntity.rotationYaw,
|
|
this.playerEntity.rotationPitch);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setPlayerLocation(double x, double y, double z, float yaw, float pitch) {
|
|
this.setPlayerLocation(x, y, z, yaw, pitch, Collections.emptySet());
|
|
}
|
|
|
|
public void setPlayerLocation(double x, double y, double z, float yaw, float pitch,
|
|
Set<S08PacketPlayerPosLook.EnumFlags> relativeSet) {
|
|
this.hasMoved = false;
|
|
this.lastPosX = x;
|
|
this.lastPosY = y;
|
|
this.lastPosZ = z;
|
|
if (relativeSet.contains(S08PacketPlayerPosLook.EnumFlags.X)) {
|
|
this.lastPosX += this.playerEntity.posX;
|
|
}
|
|
|
|
if (relativeSet.contains(S08PacketPlayerPosLook.EnumFlags.Y)) {
|
|
this.lastPosY += this.playerEntity.posY;
|
|
}
|
|
|
|
if (relativeSet.contains(S08PacketPlayerPosLook.EnumFlags.Z)) {
|
|
this.lastPosZ += this.playerEntity.posZ;
|
|
}
|
|
|
|
float f = yaw;
|
|
float f1 = pitch;
|
|
if (relativeSet.contains(S08PacketPlayerPosLook.EnumFlags.Y_ROT)) {
|
|
f = yaw + this.playerEntity.rotationYaw;
|
|
}
|
|
|
|
if (relativeSet.contains(S08PacketPlayerPosLook.EnumFlags.X_ROT)) {
|
|
f1 = pitch + this.playerEntity.rotationPitch;
|
|
}
|
|
|
|
this.playerEntity.setPositionAndRotation(this.lastPosX, this.lastPosY, this.lastPosZ, f, f1);
|
|
this.playerEntity.playerNetServerHandler
|
|
.sendPacket(new S08PacketPlayerPosLook(x, y, z, yaw, pitch, relativeSet));
|
|
}
|
|
|
|
/**+
|
|
* Processes the player initiating/stopping digging on a
|
|
* particular spot, as well as a player dropping items?. (0:
|
|
* initiated, 1: reinitiated, 2? , 3-4 drop item (respectively
|
|
* without or with player control), 5: stopped; x,y,z, side
|
|
* clicked on;)
|
|
*/
|
|
public void processPlayerDigging(C07PacketPlayerDigging c07packetplayerdigging) {
|
|
WorldServer worldserver = this.serverController.worldServerForDimension(this.playerEntity.dimension);
|
|
BlockPos blockpos = c07packetplayerdigging.getPosition();
|
|
this.playerEntity.markPlayerActive();
|
|
switch (c07packetplayerdigging.getStatus()) {
|
|
case DROP_ITEM:
|
|
if (!this.playerEntity.isSpectator()) {
|
|
this.playerEntity.dropOneItem(false);
|
|
}
|
|
|
|
return;
|
|
case DROP_ALL_ITEMS:
|
|
if (!this.playerEntity.isSpectator()) {
|
|
this.playerEntity.dropOneItem(true);
|
|
}
|
|
|
|
return;
|
|
case RELEASE_USE_ITEM:
|
|
this.playerEntity.stopUsingItem();
|
|
return;
|
|
case START_DESTROY_BLOCK:
|
|
case ABORT_DESTROY_BLOCK:
|
|
case STOP_DESTROY_BLOCK:
|
|
double d0 = this.playerEntity.posX - ((double) blockpos.getX() + 0.5D);
|
|
double d1 = this.playerEntity.posY - ((double) blockpos.getY() + 0.5D) + 1.5D;
|
|
double d2 = this.playerEntity.posZ - ((double) blockpos.getZ() + 0.5D);
|
|
double d3 = d0 * d0 + d1 * d1 + d2 * d2;
|
|
if (d3 > 36.0D) {
|
|
return;
|
|
} else if (blockpos.getY() >= this.serverController.getBuildLimit()) {
|
|
return;
|
|
} else {
|
|
if (c07packetplayerdigging.getStatus() == C07PacketPlayerDigging.Action.START_DESTROY_BLOCK) {
|
|
if (!this.serverController.isBlockProtected(worldserver, blockpos, this.playerEntity)
|
|
&& worldserver.getWorldBorder().contains(blockpos)) {
|
|
this.playerEntity.theItemInWorldManager.onBlockClicked(blockpos,
|
|
c07packetplayerdigging.getFacing());
|
|
} else {
|
|
this.playerEntity.playerNetServerHandler
|
|
.sendPacket(new S23PacketBlockChange(worldserver, blockpos));
|
|
}
|
|
} else {
|
|
if (c07packetplayerdigging.getStatus() == C07PacketPlayerDigging.Action.STOP_DESTROY_BLOCK) {
|
|
this.playerEntity.theItemInWorldManager.blockRemoving(blockpos);
|
|
} else if (c07packetplayerdigging
|
|
.getStatus() == C07PacketPlayerDigging.Action.ABORT_DESTROY_BLOCK) {
|
|
this.playerEntity.theItemInWorldManager.cancelDestroyingBlock();
|
|
}
|
|
|
|
if (worldserver.getBlockState(blockpos).getBlock().getMaterial() != Material.air) {
|
|
this.playerEntity.playerNetServerHandler
|
|
.sendPacket(new S23PacketBlockChange(worldserver, blockpos));
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
default:
|
|
throw new IllegalArgumentException("Invalid player action");
|
|
}
|
|
}
|
|
|
|
/**+
|
|
* Processes block placement and block activation (anvil,
|
|
* furnace, etc.)
|
|
*/
|
|
public void processPlayerBlockPlacement(C08PacketPlayerBlockPlacement c08packetplayerblockplacement) {
|
|
WorldServer worldserver = this.serverController.worldServerForDimension(this.playerEntity.dimension);
|
|
ItemStack itemstack = this.playerEntity.inventory.getCurrentItem();
|
|
boolean flag = false;
|
|
BlockPos blockpos = c08packetplayerblockplacement.getPosition();
|
|
EnumFacing enumfacing = EnumFacing.getFront(c08packetplayerblockplacement.getPlacedBlockDirection());
|
|
this.playerEntity.markPlayerActive();
|
|
if (c08packetplayerblockplacement.getPlacedBlockDirection() == 255) {
|
|
if (itemstack == null) {
|
|
return;
|
|
}
|
|
|
|
this.playerEntity.theItemInWorldManager.tryUseItem(this.playerEntity, worldserver, itemstack);
|
|
} else if (blockpos.getY() < this.serverController.getBuildLimit() - 1
|
|
|| enumfacing != EnumFacing.UP && blockpos.getY() < this.serverController.getBuildLimit()) {
|
|
if (this.hasMoved
|
|
&& this.playerEntity.getDistanceSq((double) blockpos.getX() + 0.5D, (double) blockpos.getY() + 0.5D,
|
|
(double) blockpos.getZ() + 0.5D) < 64.0D
|
|
&& !this.serverController.isBlockProtected(worldserver, blockpos, this.playerEntity)
|
|
&& worldserver.getWorldBorder().contains(blockpos)) {
|
|
this.playerEntity.theItemInWorldManager.activateBlockOrUseItem(this.playerEntity, worldserver,
|
|
itemstack, blockpos, enumfacing, c08packetplayerblockplacement.getPlacedBlockOffsetX(),
|
|
c08packetplayerblockplacement.getPlacedBlockOffsetY(),
|
|
c08packetplayerblockplacement.getPlacedBlockOffsetZ());
|
|
}
|
|
|
|
flag = true;
|
|
} else {
|
|
ChatComponentTranslation chatcomponenttranslation = new ChatComponentTranslation("build.tooHigh",
|
|
new Object[] { Integer.valueOf(this.serverController.getBuildLimit()) });
|
|
chatcomponenttranslation.getChatStyle().setColor(EnumChatFormatting.RED);
|
|
this.playerEntity.playerNetServerHandler.sendPacket(new S02PacketChat(chatcomponenttranslation));
|
|
flag = true;
|
|
}
|
|
|
|
if (flag) {
|
|
this.playerEntity.playerNetServerHandler.sendPacket(new S23PacketBlockChange(worldserver, blockpos));
|
|
this.playerEntity.playerNetServerHandler
|
|
.sendPacket(new S23PacketBlockChange(worldserver, blockpos.offset(enumfacing)));
|
|
}
|
|
|
|
itemstack = this.playerEntity.inventory.getCurrentItem();
|
|
if (itemstack != null && itemstack.stackSize == 0) {
|
|
this.playerEntity.inventory.mainInventory[this.playerEntity.inventory.currentItem] = null;
|
|
itemstack = null;
|
|
}
|
|
|
|
if (itemstack == null || itemstack.getMaxItemUseDuration() == 0) {
|
|
this.playerEntity.isChangingQuantityOnly = true;
|
|
this.playerEntity.inventory.mainInventory[this.playerEntity.inventory.currentItem] = ItemStack
|
|
.copyItemStack(this.playerEntity.inventory.mainInventory[this.playerEntity.inventory.currentItem]);
|
|
Slot slot = this.playerEntity.openContainer.getSlotFromInventory(this.playerEntity.inventory,
|
|
this.playerEntity.inventory.currentItem);
|
|
this.playerEntity.openContainer.detectAndSendChanges();
|
|
this.playerEntity.isChangingQuantityOnly = false;
|
|
if (!ItemStack.areItemStacksEqual(this.playerEntity.inventory.getCurrentItem(),
|
|
c08packetplayerblockplacement.getStack())) {
|
|
this.sendPacket(new S2FPacketSetSlot(this.playerEntity.openContainer.windowId, slot.slotNumber,
|
|
this.playerEntity.inventory.getCurrentItem()));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public void handleSpectate(C18PacketSpectate c18packetspectate) {
|
|
if (this.playerEntity.isSpectator()) {
|
|
Entity entity = null;
|
|
|
|
WorldServer[] srv = this.serverController.worldServers;
|
|
for (int i = 0; i < srv.length; ++i) {
|
|
WorldServer worldserver = srv[i];
|
|
if (worldserver != null) {
|
|
entity = c18packetspectate.getEntity(worldserver);
|
|
if (entity != null) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (entity != null) {
|
|
this.playerEntity.setSpectatingEntity(this.playerEntity);
|
|
this.playerEntity.mountEntity((Entity) null);
|
|
if (entity.worldObj != this.playerEntity.worldObj) {
|
|
WorldServer worldserver1 = this.playerEntity.getServerForPlayer();
|
|
WorldServer worldserver2 = (WorldServer) entity.worldObj;
|
|
this.playerEntity.dimension = entity.dimension;
|
|
this.sendPacket(new S07PacketRespawn(this.playerEntity.dimension, worldserver1.getDifficulty(),
|
|
worldserver1.getWorldInfo().getTerrainType(),
|
|
this.playerEntity.theItemInWorldManager.getGameType()));
|
|
worldserver1.removePlayerEntityDangerously(this.playerEntity);
|
|
this.playerEntity.isDead = false;
|
|
this.playerEntity.setLocationAndAngles(entity.posX, entity.posY, entity.posZ, entity.rotationYaw,
|
|
entity.rotationPitch);
|
|
if (this.playerEntity.isEntityAlive()) {
|
|
worldserver1.updateEntityWithOptionalForce(this.playerEntity, false);
|
|
worldserver2.spawnEntityInWorld(this.playerEntity);
|
|
worldserver2.updateEntityWithOptionalForce(this.playerEntity, false);
|
|
}
|
|
|
|
this.playerEntity.setWorld(worldserver2);
|
|
this.serverController.getConfigurationManager().preparePlayer(this.playerEntity, worldserver1);
|
|
this.playerEntity.setPositionAndUpdate(entity.posX, entity.posY, entity.posZ);
|
|
this.playerEntity.theItemInWorldManager.setWorld(worldserver2);
|
|
this.serverController.getConfigurationManager().updateTimeAndWeatherForPlayer(this.playerEntity,
|
|
worldserver2);
|
|
this.serverController.getConfigurationManager().syncPlayerInventory(this.playerEntity);
|
|
} else {
|
|
this.playerEntity.setPositionAndUpdate(entity.posX, entity.posY, entity.posZ);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public void handleResourcePackStatus(C19PacketResourcePackStatus var1) {
|
|
}
|
|
|
|
/**+
|
|
* Invoked when disconnecting, the parameter is a ChatComponent
|
|
* describing the reason for termination
|
|
*/
|
|
public void onDisconnect(IChatComponent ichatcomponent) {
|
|
if (!hasDisconnected) {
|
|
hasDisconnected = true;
|
|
logger.info(this.playerEntity.getName() + " lost connection: " + ichatcomponent);
|
|
this.serverController.refreshStatusNextTick();
|
|
ChatComponentTranslation chatcomponenttranslation = new ChatComponentTranslation("multiplayer.player.left",
|
|
new Object[] { this.playerEntity.getDisplayName() });
|
|
chatcomponenttranslation.getChatStyle().setColor(EnumChatFormatting.YELLOW);
|
|
this.serverController.getConfigurationManager().sendChatMsg(chatcomponenttranslation);
|
|
this.playerEntity.mountEntityAndWakeUp();
|
|
this.serverController.getConfigurationManager().playerLoggedOut(this.playerEntity);
|
|
if (this.playerEntity.getName().equals(this.serverController.getServerOwner())) {
|
|
logger.info("Stopping singleplayer server as player logged out");
|
|
this.serverController.initiateShutdown();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void sendPacket(final Packet packetIn) {
|
|
if (packetIn instanceof S02PacketChat) {
|
|
S02PacketChat s02packetchat = (S02PacketChat) packetIn;
|
|
EntityPlayer.EnumChatVisibility entityplayer$enumchatvisibility = this.playerEntity.getChatVisibility();
|
|
if (entityplayer$enumchatvisibility == EntityPlayer.EnumChatVisibility.HIDDEN) {
|
|
return;
|
|
}
|
|
|
|
if (entityplayer$enumchatvisibility == EntityPlayer.EnumChatVisibility.SYSTEM && !s02packetchat.isChat()) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
try {
|
|
this.netManager.sendPacket(packetIn);
|
|
} catch (Throwable throwable) {
|
|
CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Sending packet");
|
|
CrashReportCategory crashreportcategory = crashreport.makeCategory("Packet being sent");
|
|
crashreportcategory.addCrashSectionCallable("Packet class", new Callable<String>() {
|
|
public String call() throws Exception {
|
|
return packetIn.getClass().getCanonicalName();
|
|
}
|
|
});
|
|
throw new ReportedException(crashreport);
|
|
}
|
|
}
|
|
|
|
/**+
|
|
* Updates which quickbar slot is selected
|
|
*/
|
|
public void processHeldItemChange(C09PacketHeldItemChange c09packethelditemchange) {
|
|
if (c09packethelditemchange.getSlotId() >= 0
|
|
&& c09packethelditemchange.getSlotId() < InventoryPlayer.getHotbarSize()) {
|
|
this.playerEntity.inventory.currentItem = c09packethelditemchange.getSlotId();
|
|
this.playerEntity.markPlayerActive();
|
|
} else {
|
|
logger.warn(this.playerEntity.getName() + " tried to set an invalid carried item");
|
|
}
|
|
}
|
|
|
|
/**+
|
|
* Process chat messages (broadcast back to clients) and
|
|
* commands (executes)
|
|
*/
|
|
public void processChatMessage(C01PacketChatMessage c01packetchatmessage) {
|
|
if (this.playerEntity.getChatVisibility() == EntityPlayer.EnumChatVisibility.HIDDEN) {
|
|
ChatComponentTranslation chatcomponenttranslation = new ChatComponentTranslation("chat.cannotSend",
|
|
new Object[0]);
|
|
chatcomponenttranslation.getChatStyle().setColor(EnumChatFormatting.RED);
|
|
this.sendPacket(new S02PacketChat(chatcomponenttranslation));
|
|
} else {
|
|
this.playerEntity.markPlayerActive();
|
|
String s = c01packetchatmessage.getMessage();
|
|
s = StringUtils.normalizeSpace(s);
|
|
|
|
for (int i = 0; i < s.length(); ++i) {
|
|
if (!ChatAllowedCharacters.isAllowedCharacter(s.charAt(i))) {
|
|
this.kickPlayerFromServer("Illegal characters in chat");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (s.startsWith("/")) {
|
|
this.handleSlashCommand(s);
|
|
} else {
|
|
if (this.serverController.worldServers[0].getWorldInfo().getGameRulesInstance()
|
|
.getBoolean("colorCodes")) {
|
|
s = net.minecraft.util.StringUtils.translateControlCodesAlternate(s);
|
|
}
|
|
ChatComponentTranslation chatcomponenttranslation1 = new ChatComponentTranslation("chat.type.text",
|
|
new Object[] { this.playerEntity.getDisplayName(), s });
|
|
this.serverController.getConfigurationManager().sendChatMsgImpl(chatcomponenttranslation1, false);
|
|
}
|
|
|
|
this.chatSpamThresholdCount += 20;
|
|
if (this.chatSpamThresholdCount > 200 && !this.serverController.getConfigurationManager()
|
|
.canSendCommands(this.playerEntity.getGameProfile())) {
|
|
this.kickPlayerFromServer("disconnect.spam");
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
/**+
|
|
* Handle commands that start with a /
|
|
*/
|
|
private void handleSlashCommand(String command) {
|
|
this.serverController.getCommandManager().executeCommand(this.playerEntity, command);
|
|
}
|
|
|
|
public void handleAnimation(C0APacketAnimation c0apacketanimation) {
|
|
this.playerEntity.markPlayerActive();
|
|
this.playerEntity.swingItem();
|
|
}
|
|
|
|
/**+
|
|
* Processes a range of action-types: sneaking, sprinting,
|
|
* waking from sleep, opening the inventory or setting jump
|
|
* height of the horse the player is riding
|
|
*/
|
|
public void processEntityAction(C0BPacketEntityAction c0bpacketentityaction) {
|
|
this.playerEntity.markPlayerActive();
|
|
switch (c0bpacketentityaction.getAction()) {
|
|
case START_SNEAKING:
|
|
this.playerEntity.setSneaking(true);
|
|
break;
|
|
case STOP_SNEAKING:
|
|
this.playerEntity.setSneaking(false);
|
|
break;
|
|
case START_SPRINTING:
|
|
this.playerEntity.setSprinting(true);
|
|
break;
|
|
case STOP_SPRINTING:
|
|
this.playerEntity.setSprinting(false);
|
|
break;
|
|
case STOP_SLEEPING:
|
|
this.playerEntity.wakeUpPlayer(false, true, true);
|
|
this.hasMoved = false;
|
|
break;
|
|
case RIDING_JUMP:
|
|
if (this.playerEntity.ridingEntity instanceof EntityHorse) {
|
|
((EntityHorse) this.playerEntity.ridingEntity).setJumpPower(c0bpacketentityaction.getAuxData());
|
|
}
|
|
break;
|
|
case OPEN_INVENTORY:
|
|
if (this.playerEntity.ridingEntity instanceof EntityHorse) {
|
|
((EntityHorse) this.playerEntity.ridingEntity).openGUI(this.playerEntity);
|
|
}
|
|
break;
|
|
default:
|
|
throw new IllegalArgumentException("Invalid client command!");
|
|
}
|
|
|
|
}
|
|
|
|
/**+
|
|
* Processes interactions ((un)leashing, opening command block
|
|
* GUI) and attacks on an entity with players currently equipped
|
|
* item
|
|
*/
|
|
public void processUseEntity(C02PacketUseEntity c02packetuseentity) {
|
|
WorldServer worldserver = this.serverController.worldServerForDimension(this.playerEntity.dimension);
|
|
Entity entity = c02packetuseentity.getEntityFromWorld(worldserver);
|
|
this.playerEntity.markPlayerActive();
|
|
if (entity != null) {
|
|
boolean flag = this.playerEntity.canEntityBeSeen(entity);
|
|
double d0 = 36.0D;
|
|
if (!flag) {
|
|
d0 = 9.0D;
|
|
}
|
|
|
|
if (this.playerEntity.getDistanceSqToEntity(entity) < d0) {
|
|
if (c02packetuseentity.getAction() == C02PacketUseEntity.Action.INTERACT) {
|
|
this.playerEntity.interactWith(entity);
|
|
} else if (c02packetuseentity.getAction() == C02PacketUseEntity.Action.INTERACT_AT) {
|
|
entity.interactAt(this.playerEntity, c02packetuseentity.getHitVec());
|
|
} else if (c02packetuseentity.getAction() == C02PacketUseEntity.Action.ATTACK) {
|
|
if (entity instanceof EntityItem || entity instanceof EntityXPOrb || entity instanceof EntityArrow
|
|
|| entity == this.playerEntity) {
|
|
this.kickPlayerFromServer("Attempting to attack an invalid entity");
|
|
this.serverController.logWarning(
|
|
"Player " + this.playerEntity.getName() + " tried to attack an invalid entity");
|
|
return;
|
|
}
|
|
|
|
this.playerEntity.attackTargetEntityWithCurrentItem(entity);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**+
|
|
* Processes the client status updates: respawn attempt from
|
|
* player, opening statistics or achievements, or acquiring
|
|
* 'open inventory' achievement
|
|
*/
|
|
public void processClientStatus(C16PacketClientStatus c16packetclientstatus) {
|
|
this.playerEntity.markPlayerActive();
|
|
C16PacketClientStatus.EnumState c16packetclientstatus$enumstate = c16packetclientstatus.getStatus();
|
|
switch (c16packetclientstatus$enumstate) {
|
|
case PERFORM_RESPAWN:
|
|
if (this.playerEntity.playerConqueredTheEnd) {
|
|
this.playerEntity = this.serverController.getConfigurationManager()
|
|
.recreatePlayerEntity(this.playerEntity, 0, true);
|
|
} else if (this.playerEntity.getServerForPlayer().getWorldInfo().isHardcoreModeEnabled()) {
|
|
if (this.serverController.isSinglePlayer()
|
|
&& this.playerEntity.getName().equals(this.serverController.getServerOwner())) {
|
|
this.playerEntity.playerNetServerHandler
|
|
.kickPlayerFromServer("You have died. Game over, man, it\'s game over!");
|
|
this.serverController.deleteWorldAndStopServer();
|
|
} else {
|
|
this.playerEntity.playerNetServerHandler
|
|
.kickPlayerFromServer("You have died. Game over, man, it\'s game over!");
|
|
}
|
|
} else {
|
|
if (this.playerEntity.getHealth() > 0.0F) {
|
|
return;
|
|
}
|
|
|
|
this.playerEntity = this.serverController.getConfigurationManager()
|
|
.recreatePlayerEntity(this.playerEntity, 0, false);
|
|
}
|
|
break;
|
|
case REQUEST_STATS:
|
|
this.playerEntity.getStatFile().func_150876_a(this.playerEntity);
|
|
break;
|
|
case OPEN_INVENTORY_ACHIEVEMENT:
|
|
this.playerEntity.triggerAchievement(AchievementList.openInventory);
|
|
}
|
|
|
|
}
|
|
|
|
/**+
|
|
* Processes the client closing windows (container)
|
|
*/
|
|
public void processCloseWindow(C0DPacketCloseWindow c0dpacketclosewindow) {
|
|
this.playerEntity.closeContainer();
|
|
}
|
|
|
|
/**+
|
|
* Executes a container/inventory slot manipulation as indicated
|
|
* by the packet. Sends the serverside result if they didn't
|
|
* match the indicated result and prevents further manipulation
|
|
* by the player until he confirms that it has the same open
|
|
* container/inventory
|
|
*/
|
|
public void processClickWindow(C0EPacketClickWindow c0epacketclickwindow) {
|
|
this.playerEntity.markPlayerActive();
|
|
if (this.playerEntity.openContainer.windowId == c0epacketclickwindow.getWindowId()
|
|
&& this.playerEntity.openContainer.getCanCraft(this.playerEntity)) {
|
|
if (this.playerEntity.isSpectator()) {
|
|
ArrayList arraylist = Lists.newArrayList();
|
|
|
|
for (int i = 0; i < this.playerEntity.openContainer.inventorySlots.size(); ++i) {
|
|
arraylist.add(((Slot) this.playerEntity.openContainer.inventorySlots.get(i)).getStack());
|
|
}
|
|
|
|
this.playerEntity.updateCraftingInventory(this.playerEntity.openContainer, arraylist);
|
|
} else {
|
|
ItemStack itemstack = this.playerEntity.openContainer.slotClick(c0epacketclickwindow.getSlotId(),
|
|
c0epacketclickwindow.getUsedButton(), c0epacketclickwindow.getMode(), this.playerEntity);
|
|
if (ItemStack.areItemStacksEqual(c0epacketclickwindow.getClickedItem(), itemstack)) {
|
|
this.playerEntity.playerNetServerHandler.sendPacket(new S32PacketConfirmTransaction(
|
|
c0epacketclickwindow.getWindowId(), c0epacketclickwindow.getActionNumber(), true));
|
|
this.playerEntity.isChangingQuantityOnly = true;
|
|
this.playerEntity.openContainer.detectAndSendChanges();
|
|
this.playerEntity.updateHeldItem();
|
|
this.playerEntity.isChangingQuantityOnly = false;
|
|
} else {
|
|
this.field_147372_n.addKey(this.playerEntity.openContainer.windowId,
|
|
Short.valueOf(c0epacketclickwindow.getActionNumber()));
|
|
this.playerEntity.playerNetServerHandler.sendPacket(new S32PacketConfirmTransaction(
|
|
c0epacketclickwindow.getWindowId(), c0epacketclickwindow.getActionNumber(), false));
|
|
this.playerEntity.openContainer.setCanCraft(this.playerEntity, false);
|
|
ArrayList arraylist1 = Lists.newArrayList();
|
|
|
|
for (int j = 0; j < this.playerEntity.openContainer.inventorySlots.size(); ++j) {
|
|
arraylist1.add(((Slot) this.playerEntity.openContainer.inventorySlots.get(j)).getStack());
|
|
}
|
|
|
|
this.playerEntity.updateCraftingInventory(this.playerEntity.openContainer, arraylist1);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**+
|
|
* Enchants the item identified by the packet given some
|
|
* convoluted conditions (matching window, which
|
|
* should/shouldn't be in use?)
|
|
*/
|
|
public void processEnchantItem(C11PacketEnchantItem c11packetenchantitem) {
|
|
this.playerEntity.markPlayerActive();
|
|
if (this.playerEntity.openContainer.windowId == c11packetenchantitem.getWindowId()
|
|
&& this.playerEntity.openContainer.getCanCraft(this.playerEntity) && !this.playerEntity.isSpectator()) {
|
|
this.playerEntity.openContainer.enchantItem(this.playerEntity, c11packetenchantitem.getButton());
|
|
this.playerEntity.openContainer.detectAndSendChanges();
|
|
}
|
|
|
|
}
|
|
|
|
/**+
|
|
* Update the server with an ItemStack in a slot.
|
|
*/
|
|
public void processCreativeInventoryAction(C10PacketCreativeInventoryAction c10packetcreativeinventoryaction) {
|
|
if (this.playerEntity.theItemInWorldManager.isCreative()) {
|
|
boolean flag = c10packetcreativeinventoryaction.getSlotId() < 0;
|
|
ItemStack itemstack = c10packetcreativeinventoryaction.getStack();
|
|
if (itemstack != null && itemstack.hasTagCompound()
|
|
&& itemstack.getTagCompound().hasKey("BlockEntityTag", 10)) {
|
|
NBTTagCompound nbttagcompound = itemstack.getTagCompound().getCompoundTag("BlockEntityTag");
|
|
if (nbttagcompound.hasKey("x") && nbttagcompound.hasKey("y") && nbttagcompound.hasKey("z")) {
|
|
BlockPos blockpos = new BlockPos(nbttagcompound.getInteger("x"), nbttagcompound.getInteger("y"),
|
|
nbttagcompound.getInteger("z"));
|
|
TileEntity tileentity = this.playerEntity.worldObj.getTileEntity(blockpos);
|
|
if (tileentity != null) {
|
|
NBTTagCompound nbttagcompound1 = new NBTTagCompound();
|
|
tileentity.writeToNBT(nbttagcompound1);
|
|
nbttagcompound1.removeTag("x");
|
|
nbttagcompound1.removeTag("y");
|
|
nbttagcompound1.removeTag("z");
|
|
itemstack.setTagInfo("BlockEntityTag", nbttagcompound1);
|
|
}
|
|
}
|
|
}
|
|
|
|
boolean flag1 = c10packetcreativeinventoryaction.getSlotId() >= 1
|
|
&& c10packetcreativeinventoryaction.getSlotId() < 36 + InventoryPlayer.getHotbarSize();
|
|
boolean flag2 = itemstack == null || itemstack.getItem() != null;
|
|
boolean flag3 = itemstack == null
|
|
|| itemstack.getMetadata() >= 0 && itemstack.stackSize <= 64 && itemstack.stackSize > 0;
|
|
if (flag1 && flag2 && flag3) {
|
|
if (itemstack == null) {
|
|
this.playerEntity.inventoryContainer.putStackInSlot(c10packetcreativeinventoryaction.getSlotId(),
|
|
(ItemStack) null);
|
|
} else {
|
|
this.playerEntity.inventoryContainer.putStackInSlot(c10packetcreativeinventoryaction.getSlotId(),
|
|
itemstack);
|
|
}
|
|
|
|
this.playerEntity.inventoryContainer.setCanCraft(this.playerEntity, true);
|
|
} else if (flag && flag2 && flag3 && this.itemDropThreshold < 200) {
|
|
this.itemDropThreshold += 20;
|
|
EntityItem entityitem = this.playerEntity.dropPlayerItemWithRandomChoice(itemstack, true);
|
|
if (entityitem != null) {
|
|
entityitem.setAgeToCreativeDespawnTime();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**+
|
|
* Received in response to the server requesting to confirm that
|
|
* the client-side open container matches the servers' after a
|
|
* mismatched container-slot manipulation. It will unlock the
|
|
* player's ability to manipulate the container contents
|
|
*/
|
|
public void processConfirmTransaction(C0FPacketConfirmTransaction c0fpacketconfirmtransaction) {
|
|
Short oshort = (Short) this.field_147372_n.lookup(this.playerEntity.openContainer.windowId);
|
|
if (oshort != null && c0fpacketconfirmtransaction.getUid() == oshort.shortValue()
|
|
&& this.playerEntity.openContainer.windowId == c0fpacketconfirmtransaction.getWindowId()
|
|
&& !this.playerEntity.openContainer.getCanCraft(this.playerEntity)
|
|
&& !this.playerEntity.isSpectator()) {
|
|
this.playerEntity.openContainer.setCanCraft(this.playerEntity, true);
|
|
}
|
|
|
|
}
|
|
|
|
public void processUpdateSign(C12PacketUpdateSign c12packetupdatesign) {
|
|
this.playerEntity.markPlayerActive();
|
|
WorldServer worldserver = this.serverController.worldServerForDimension(this.playerEntity.dimension);
|
|
BlockPos blockpos = c12packetupdatesign.getPosition();
|
|
if (worldserver.isBlockLoaded(blockpos)) {
|
|
TileEntity tileentity = worldserver.getTileEntity(blockpos);
|
|
if (!(tileentity instanceof TileEntitySign)) {
|
|
return;
|
|
}
|
|
|
|
TileEntitySign tileentitysign = (TileEntitySign) tileentity;
|
|
if (!tileentitysign.getIsEditable() || tileentitysign.getPlayer() != this.playerEntity) {
|
|
this.serverController.logWarning(
|
|
"Player " + this.playerEntity.getName() + " just tried to change non-editable sign");
|
|
return;
|
|
}
|
|
|
|
IChatComponent[] aichatcomponent = c12packetupdatesign.getLines();
|
|
|
|
for (int i = 0; i < aichatcomponent.length; ++i) {
|
|
String s = EnumChatFormatting.getTextWithoutFormattingCodes(aichatcomponent[i].getUnformattedText());
|
|
if (this.serverController.worldServers[0].getWorldInfo().getGameRulesInstance()
|
|
.getBoolean("colorCodes")) {
|
|
s = net.minecraft.util.StringUtils.translateControlCodesAlternate(s);
|
|
}
|
|
tileentitysign.signText[i] = new ChatComponentText(s);
|
|
}
|
|
|
|
tileentitysign.markDirty();
|
|
worldserver.markBlockForUpdate(blockpos);
|
|
}
|
|
|
|
}
|
|
|
|
/**+
|
|
* Updates a players' ping statistics
|
|
*/
|
|
public void processKeepAlive(C00PacketKeepAlive c00packetkeepalive) {
|
|
if (c00packetkeepalive.getKey() == this.field_147378_h) {
|
|
int i = (int) (this.currentTimeMillis() - this.lastPingTime);
|
|
this.playerEntity.ping = (this.playerEntity.ping * 3 + i) / 4;
|
|
}
|
|
|
|
}
|
|
|
|
private long currentTimeMillis() {
|
|
return System.nanoTime() / 1000000L;
|
|
}
|
|
|
|
/**+
|
|
* Processes a player starting/stopping flying
|
|
*/
|
|
public void processPlayerAbilities(C13PacketPlayerAbilities c13packetplayerabilities) {
|
|
this.playerEntity.capabilities.isFlying = c13packetplayerabilities.isFlying()
|
|
&& this.playerEntity.capabilities.allowFlying;
|
|
}
|
|
|
|
/**+
|
|
* Retrieves possible tab completions for the requested command
|
|
* string and sends them to the client
|
|
*/
|
|
public void processTabComplete(C14PacketTabComplete c14packettabcomplete) {
|
|
List<String> lst = this.serverController.getTabCompletions(this.playerEntity, c14packettabcomplete.getMessage(),
|
|
c14packettabcomplete.getTargetBlock());
|
|
String[] fuckOff = new String[lst.size()];
|
|
for (int i = 0; i < fuckOff.length; ++i) {
|
|
fuckOff[i] = lst.get(i);
|
|
}
|
|
|
|
this.playerEntity.playerNetServerHandler.sendPacket(new S3APacketTabComplete(fuckOff));
|
|
}
|
|
|
|
/**+
|
|
* Updates serverside copy of client settings: language, render
|
|
* distance, chat visibility, chat colours, difficulty, and
|
|
* whether to show the cape
|
|
*/
|
|
public void processClientSettings(C15PacketClientSettings c15packetclientsettings) {
|
|
this.playerEntity.handleClientSettings(c15packetclientsettings);
|
|
}
|
|
|
|
/**+
|
|
* Synchronizes serverside and clientside book contents and
|
|
* signing
|
|
*/
|
|
public void processVanilla250Packet(C17PacketCustomPayload c17packetcustompayload) {
|
|
if ("MC|BEdit".equals(c17packetcustompayload.getChannelName())) {
|
|
PacketBuffer packetbuffer3 = c17packetcustompayload.getBufferData();
|
|
|
|
try {
|
|
ItemStack itemstack1 = packetbuffer3.readItemStackFromBuffer();
|
|
if (itemstack1 != null) {
|
|
if (!ItemWritableBook.isNBTValid(itemstack1.getTagCompound())) {
|
|
throw new IOException("Invalid book tag!");
|
|
}
|
|
|
|
ItemStack itemstack3 = this.playerEntity.inventory.getCurrentItem();
|
|
if (itemstack3 == null) {
|
|
return;
|
|
}
|
|
|
|
if (itemstack1.getItem() == Items.writable_book && itemstack1.getItem() == itemstack3.getItem()) {
|
|
itemstack3.setTagInfo("pages", itemstack1.getTagCompound().getTagList("pages", 8));
|
|
}
|
|
|
|
return;
|
|
}
|
|
} catch (Exception exception3) {
|
|
logger.error("Couldn\'t handle book info", exception3);
|
|
logger.error(exception3);
|
|
return;
|
|
}
|
|
|
|
return;
|
|
} else if ("MC|BSign".equals(c17packetcustompayload.getChannelName())) {
|
|
PacketBuffer packetbuffer2 = c17packetcustompayload.getBufferData();
|
|
|
|
try {
|
|
ItemStack itemstack = packetbuffer2.readItemStackFromBuffer();
|
|
if (itemstack != null) {
|
|
if (!ItemEditableBook.validBookTagContents(itemstack.getTagCompound())) {
|
|
throw new IOException("Invalid book tag!");
|
|
}
|
|
|
|
ItemStack itemstack2 = this.playerEntity.inventory.getCurrentItem();
|
|
if (itemstack2 == null) {
|
|
return;
|
|
}
|
|
|
|
if (itemstack.getItem() == Items.written_book && itemstack2.getItem() == Items.writable_book) {
|
|
itemstack2.setTagInfo("author", new NBTTagString(this.playerEntity.getName()));
|
|
itemstack2.setTagInfo("title", new NBTTagString(itemstack.getTagCompound().getString("title")));
|
|
itemstack2.setTagInfo("pages", itemstack.getTagCompound().getTagList("pages", 8));
|
|
itemstack2.setItem(Items.written_book);
|
|
}
|
|
|
|
return;
|
|
}
|
|
} catch (Exception exception4) {
|
|
logger.error("Couldn\'t sign book", exception4);
|
|
logger.error(exception4);
|
|
return;
|
|
}
|
|
|
|
return;
|
|
} else if ("MC|TrSel".equals(c17packetcustompayload.getChannelName())) {
|
|
try {
|
|
int i = c17packetcustompayload.getBufferData().readInt();
|
|
Container container = this.playerEntity.openContainer;
|
|
if (container instanceof ContainerMerchant) {
|
|
((ContainerMerchant) container).setCurrentRecipeIndex(i);
|
|
}
|
|
} catch (Exception exception2) {
|
|
logger.error("Couldn\'t select trade", exception2);
|
|
}
|
|
} else if ("MC|AdvCdm".equals(c17packetcustompayload.getChannelName())) {
|
|
if (!this.serverController.isCommandBlockEnabled()) {
|
|
this.playerEntity.addChatMessage(new ChatComponentTranslation("advMode.notEnabled", new Object[0]));
|
|
} else if (this.playerEntity.canCommandSenderUseCommand(2, "")
|
|
&& this.playerEntity.capabilities.isCreativeMode) {
|
|
PacketBuffer packetbuffer = c17packetcustompayload.getBufferData();
|
|
|
|
try {
|
|
byte b0 = packetbuffer.readByte();
|
|
CommandBlockLogic commandblocklogic = null;
|
|
if (b0 == 0) {
|
|
TileEntity tileentity = this.playerEntity.worldObj.getTileEntity(
|
|
new BlockPos(packetbuffer.readInt(), packetbuffer.readInt(), packetbuffer.readInt()));
|
|
if (tileentity instanceof TileEntityCommandBlock) {
|
|
commandblocklogic = ((TileEntityCommandBlock) tileentity).getCommandBlockLogic();
|
|
}
|
|
} else if (b0 == 1) {
|
|
Entity entity = this.playerEntity.worldObj.getEntityByID(packetbuffer.readInt());
|
|
if (entity instanceof EntityMinecartCommandBlock) {
|
|
commandblocklogic = ((EntityMinecartCommandBlock) entity).getCommandBlockLogic();
|
|
}
|
|
}
|
|
|
|
String s1 = packetbuffer.readStringFromBuffer(packetbuffer.readableBytes());
|
|
boolean flag = packetbuffer.readBoolean();
|
|
if (commandblocklogic != null) {
|
|
commandblocklogic.setCommand(s1);
|
|
commandblocklogic.setTrackOutput(flag);
|
|
if (!flag) {
|
|
commandblocklogic.setLastOutput((IChatComponent) null);
|
|
}
|
|
|
|
commandblocklogic.updateCommand();
|
|
this.playerEntity.addChatMessage(
|
|
new ChatComponentTranslation("advMode.setCommand.success", new Object[] { s1 }));
|
|
}
|
|
} catch (Exception exception1) {
|
|
logger.error("Couldn\'t set command block", exception1);
|
|
}
|
|
} else {
|
|
this.playerEntity.addChatMessage(new ChatComponentTranslation("advMode.notAllowed", new Object[0]));
|
|
}
|
|
} else if ("MC|Beacon".equals(c17packetcustompayload.getChannelName())) {
|
|
if (this.playerEntity.openContainer instanceof ContainerBeacon) {
|
|
try {
|
|
PacketBuffer packetbuffer1 = c17packetcustompayload.getBufferData();
|
|
int j = packetbuffer1.readInt();
|
|
int k = packetbuffer1.readInt();
|
|
ContainerBeacon containerbeacon = (ContainerBeacon) this.playerEntity.openContainer;
|
|
Slot slot = containerbeacon.getSlot(0);
|
|
if (slot.getHasStack()) {
|
|
slot.decrStackSize(1);
|
|
IInventory iinventory = containerbeacon.func_180611_e();
|
|
iinventory.setField(1, j);
|
|
iinventory.setField(2, k);
|
|
iinventory.markDirty();
|
|
}
|
|
} catch (Exception exception) {
|
|
logger.error("Couldn\'t set beacon", exception);
|
|
}
|
|
}
|
|
} else if ("MC|ItemName".equals(c17packetcustompayload.getChannelName())
|
|
&& this.playerEntity.openContainer instanceof ContainerRepair) {
|
|
ContainerRepair containerrepair = (ContainerRepair) this.playerEntity.openContainer;
|
|
if (c17packetcustompayload.getBufferData() != null
|
|
&& c17packetcustompayload.getBufferData().readableBytes() >= 1) {
|
|
String s = ChatAllowedCharacters
|
|
.filterAllowedCharacters(c17packetcustompayload.getBufferData().readStringFromBuffer(32767));
|
|
if (s.length() <= 30) {
|
|
if (this.serverController.worldServers[0].getWorldInfo().getGameRulesInstance()
|
|
.getBoolean("colorCodes")) {
|
|
s = net.minecraft.util.StringUtils.translateControlCodesAlternate(s);
|
|
}
|
|
containerrepair.updateItemName(s);
|
|
}
|
|
} else {
|
|
containerrepair.updateItemName("");
|
|
}
|
|
} else if ("EAG|Skins-1.8".equals(c17packetcustompayload.getChannelName())) {
|
|
byte[] r = new byte[c17packetcustompayload.getBufferData().readableBytes()];
|
|
c17packetcustompayload.getBufferData().readBytes(r);
|
|
((EaglerMinecraftServer) serverController).getSkinService().processPacket(r, playerEntity);
|
|
} else if ("EAG|Capes-1.8".equals(c17packetcustompayload.getChannelName())) {
|
|
byte[] r = new byte[c17packetcustompayload.getBufferData().readableBytes()];
|
|
c17packetcustompayload.getBufferData().readBytes(r);
|
|
((EaglerMinecraftServer) serverController).getCapeService().processPacket(r, playerEntity);
|
|
} else if ("EAG|Voice-1.8".equals(c17packetcustompayload.getChannelName())) {
|
|
IntegratedVoiceService vcs = ((EaglerMinecraftServer) serverController).getVoiceService();
|
|
if (vcs != null) {
|
|
vcs.processPacket(c17packetcustompayload.getBufferData(), playerEntity);
|
|
}
|
|
} else if ("EAG|MyUpdCert-1.8".equals(c17packetcustompayload.getChannelName())) {
|
|
if (playerEntity.updateCertificate == null) {
|
|
PacketBuffer pb = c17packetcustompayload.getBufferData();
|
|
byte[] cert = new byte[pb.readableBytes()];
|
|
pb.readBytes(cert);
|
|
playerEntity.updateCertificate = cert;
|
|
List<EntityPlayerMP> lst = playerEntity.mcServer.getConfigurationManager().func_181057_v();
|
|
for (int i = 0, l = lst.size(); i < l; ++i) {
|
|
EntityPlayerMP player = lst.get(i);
|
|
if (player != playerEntity) {
|
|
player.playerNetServerHandler.sendPacket(new S3FPacketCustomPayload("EAG|UpdateCert-1.8",
|
|
new PacketBuffer(Unpooled.buffer(cert, cert.length).writerIndex(cert.length))));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} |