package net.minecraft.world.entity.player;

import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.math.IntMath;
import com.mojang.authlib.GameProfile;
import com.mojang.datafixers.util.Either;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.OptionalInt;
import java.util.function.Predicate;
import net.minecraft.Util;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.core.GlobalPos;
import net.minecraft.core.component.DataComponents;
import net.minecraft.core.particles.ParticleTypes;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.nbt.ListTag;
import net.minecraft.nbt.NbtUtils;
import net.minecraft.network.chat.ClickEvent;
import net.minecraft.network.chat.Component;
import net.minecraft.network.chat.MutableComponent;
import net.minecraft.network.protocol.game.ClientboundSetEntityMotionPacket;
import net.minecraft.network.syncher.EntityDataAccessor;
import net.minecraft.network.syncher.EntityDataSerializers;
import net.minecraft.network.syncher.SynchedEntityData;
import net.minecraft.resources.ResourceKey;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.sounds.SoundEvent;
import net.minecraft.sounds.SoundEvents;
import net.minecraft.sounds.SoundSource;
import net.minecraft.stats.Stat;
import net.minecraft.stats.Stats;
import net.minecraft.tags.BlockTags;
import net.minecraft.tags.DamageTypeTags;
import net.minecraft.tags.EntityTypeTags;
import net.minecraft.tags.FluidTags;
import net.minecraft.tags.ItemTags;
import net.minecraft.util.Mth;
import net.minecraft.util.Unit;
import net.minecraft.world.Container;
import net.minecraft.world.Difficulty;
import net.minecraft.world.InteractionHand;
import net.minecraft.world.InteractionResult;
import net.minecraft.world.MenuProvider;
import net.minecraft.world.damagesource.DamageSource;
import net.minecraft.world.effect.MobEffectInstance;
import net.minecraft.world.effect.MobEffectUtil;
import net.minecraft.world.effect.MobEffects;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.EntityAttachment;
import net.minecraft.world.entity.EntityAttachments;
import net.minecraft.world.entity.EntityDimensions;
import net.minecraft.world.entity.EntityEquipment;
import net.minecraft.world.entity.EntitySpawnReason;
import net.minecraft.world.entity.EntityType;
import net.minecraft.world.entity.EquipmentSlot;
import net.minecraft.world.entity.HumanoidArm;
import net.minecraft.world.entity.LivingEntity;
import net.minecraft.world.entity.MoverType;
import net.minecraft.world.entity.Pose;
import net.minecraft.world.entity.SlotAccess;
import net.minecraft.world.entity.TamableAnimal;
import net.minecraft.world.entity.ai.attributes.Attributes;
import net.minecraft.world.entity.ai.attributes.AttributeSupplier.Builder;
import net.minecraft.world.entity.animal.Parrot;
import net.minecraft.world.entity.animal.horse.AbstractHorse;
import net.minecraft.world.entity.boss.EnderDragonPart;
import net.minecraft.world.entity.decoration.ArmorStand;
import net.minecraft.world.entity.item.ItemEntity;
import net.minecraft.world.entity.monster.warden.WardenSpawnTracker;
import net.minecraft.world.entity.projectile.FishingHook;
import net.minecraft.world.entity.projectile.Projectile;
import net.minecraft.world.entity.projectile.ProjectileDeflection;
import net.minecraft.world.food.FoodData;
import net.minecraft.world.inventory.AbstractContainerMenu;
import net.minecraft.world.inventory.ClickAction;
import net.minecraft.world.inventory.InventoryMenu;
import net.minecraft.world.inventory.PlayerEnderChestContainer;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.ItemCooldowns;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.Items;
import net.minecraft.world.item.ProjectileWeaponItem;
import net.minecraft.world.item.component.BlocksAttacks;
import net.minecraft.world.item.crafting.Recipe;
import net.minecraft.world.item.crafting.RecipeHolder;
import net.minecraft.world.item.enchantment.EnchantmentEffectComponents;
import net.minecraft.world.item.enchantment.EnchantmentHelper;
import net.minecraft.world.item.equipment.Equippable;
import net.minecraft.world.item.trading.MerchantOffers;
import net.minecraft.world.level.BaseCommandBlock;
import net.minecraft.world.level.GameRules;
import net.minecraft.world.level.GameType;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.entity.CommandBlockEntity;
import net.minecraft.world.level.block.entity.JigsawBlockEntity;
import net.minecraft.world.level.block.entity.SignBlockEntity;
import net.minecraft.world.level.block.entity.StructureBlockEntity;
import net.minecraft.world.level.block.entity.TestBlockEntity;
import net.minecraft.world.level.block.entity.TestInstanceBlockEntity;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.block.state.pattern.BlockInWorld;
import net.minecraft.world.level.gameevent.GameEvent;
import net.minecraft.world.level.gameevent.GameEvent.Context;
import net.minecraft.world.phys.AABB;
import net.minecraft.world.phys.Vec3;
import net.minecraft.world.scores.PlayerTeam;
import net.minecraft.world.scores.Scoreboard;
import net.minecraft.world.scores.Team;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public abstract class Player extends LivingEntity {
	public static final HumanoidArm DEFAULT_MAIN_HAND = HumanoidArm.RIGHT;
	public static final int DEFAULT_MODEL_CUSTOMIZATION = 0;
	public static final int MAX_HEALTH = 20;
	public static final int SLEEP_DURATION = 100;
	public static final int WAKE_UP_DURATION = 10;
	public static final int ENDER_SLOT_OFFSET = 200;
	public static final int HELD_ITEM_SLOT = 499;
	public static final int CRAFTING_SLOT_OFFSET = 500;
	public static final float DEFAULT_BLOCK_INTERACTION_RANGE = 4.5F;
	public static final float DEFAULT_ENTITY_INTERACTION_RANGE = 3.0F;
	public static final float CROUCH_BB_HEIGHT = 1.5F;
	public static final float SWIMMING_BB_WIDTH = 0.6F;
	public static final float SWIMMING_BB_HEIGHT = 0.6F;
	public static final float DEFAULT_EYE_HEIGHT = 1.62F;
	private static final int CURRENT_IMPULSE_CONTEXT_RESET_GRACE_TIME_TICKS = 40;
	public static final Vec3 DEFAULT_VEHICLE_ATTACHMENT = new Vec3(0.0, 0.6, 0.0);
	public static final EntityDimensions STANDING_DIMENSIONS = EntityDimensions.scalable(0.6F, 1.8F)
		.withEyeHeight(1.62F)
		.withAttachments(EntityAttachments.builder().attach(EntityAttachment.VEHICLE, DEFAULT_VEHICLE_ATTACHMENT));
	private static final Map<Pose, EntityDimensions> POSES = ImmutableMap.<Pose, EntityDimensions>builder()
		.put(Pose.STANDING, STANDING_DIMENSIONS)
		.put(Pose.SLEEPING, SLEEPING_DIMENSIONS)
		.put(Pose.FALL_FLYING, EntityDimensions.scalable(0.6F, 0.6F).withEyeHeight(0.4F))
		.put(Pose.SWIMMING, EntityDimensions.scalable(0.6F, 0.6F).withEyeHeight(0.4F))
		.put(Pose.SPIN_ATTACK, EntityDimensions.scalable(0.6F, 0.6F).withEyeHeight(0.4F))
		.put(
			Pose.CROUCHING,
			EntityDimensions.scalable(0.6F, 1.5F)
				.withEyeHeight(1.27F)
				.withAttachments(EntityAttachments.builder().attach(EntityAttachment.VEHICLE, DEFAULT_VEHICLE_ATTACHMENT))
		)
		.put(Pose.DYING, EntityDimensions.fixed(0.2F, 0.2F).withEyeHeight(1.62F))
		.build();
	private static final EntityDataAccessor<Float> DATA_PLAYER_ABSORPTION_ID = SynchedEntityData.defineId(Player.class, EntityDataSerializers.FLOAT);
	private static final EntityDataAccessor<Integer> DATA_SCORE_ID = SynchedEntityData.defineId(Player.class, EntityDataSerializers.INT);
	protected static final EntityDataAccessor<Byte> DATA_PLAYER_MODE_CUSTOMISATION = SynchedEntityData.defineId(Player.class, EntityDataSerializers.BYTE);
	protected static final EntityDataAccessor<Byte> DATA_PLAYER_MAIN_HAND = SynchedEntityData.defineId(Player.class, EntityDataSerializers.BYTE);
	protected static final EntityDataAccessor<CompoundTag> DATA_SHOULDER_LEFT = SynchedEntityData.defineId(Player.class, EntityDataSerializers.COMPOUND_TAG);
	protected static final EntityDataAccessor<CompoundTag> DATA_SHOULDER_RIGHT = SynchedEntityData.defineId(Player.class, EntityDataSerializers.COMPOUND_TAG);
	public static final int CLIENT_LOADED_TIMEOUT_TIME = 60;
	private static final short DEFAULT_SLEEP_TIMER = 0;
	private static final float DEFAULT_EXPERIENCE_PROGRESS = 0.0F;
	private static final int DEFAULT_EXPERIENCE_LEVEL = 0;
	private static final int DEFAULT_TOTAL_EXPERIENCE = 0;
	private static final int NO_ENCHANTMENT_SEED = 0;
	private static final int DEFAULT_SELECTED_SLOT = 0;
	private static final int DEFAULT_SCORE = 0;
	private static final boolean DEFAULT_IGNORE_FALL_DAMAGE_FROM_CURRENT_IMPULSE = false;
	private static final int DEFAULT_CURRENT_IMPULSE_CONTEXT_RESET_GRACE_TIME = 0;
	private long timeEntitySatOnShoulder;
	final Inventory inventory;
	protected PlayerEnderChestContainer enderChestInventory = new PlayerEnderChestContainer();
	public final InventoryMenu inventoryMenu;
	public AbstractContainerMenu containerMenu;
	protected FoodData foodData = new FoodData();
	protected int jumpTriggerTime;
	private boolean clientLoaded = false;
	protected int clientLoadedTimeoutTimer = 60;
	public float oBob;
	public float bob;
	public int takeXpDelay;
	public double xCloakO;
	public double yCloakO;
	public double zCloakO;
	public double xCloak;
	public double yCloak;
	public double zCloak;
	private int sleepCounter = 0;
	protected boolean wasUnderwater;
	private final Abilities abilities = new Abilities();
	public int experienceLevel = 0;
	public int totalExperience = 0;
	public float experienceProgress = 0.0F;
	protected int enchantmentSeed = 0;
	protected final float defaultFlySpeed = 0.02F;
	private int lastLevelUpTime;
	/**
	 * The player's unique game profile
	 */
	private final GameProfile gameProfile;
	private boolean reducedDebugInfo;
	private ItemStack lastItemInMainHand = ItemStack.EMPTY;
	private final ItemCooldowns cooldowns = this.createItemCooldowns();
	private Optional<GlobalPos> lastDeathLocation = Optional.empty();
	@Nullable
	public FishingHook fishing;
	protected float hurtDir;
	@Nullable
	public Vec3 currentImpulseImpactPos;
	@Nullable
	public Entity currentExplosionCause;
	private boolean ignoreFallDamageFromCurrentImpulse = false;
	private int currentImpulseContextResetGraceTime = 0;

	public Player(Level level, BlockPos pos, float yRot, GameProfile gameProfile) {
		super(EntityType.PLAYER, level);
		this.setUUID(gameProfile.getId());
		this.gameProfile = gameProfile;
		this.inventory = new Inventory(this, this.equipment);
		this.inventoryMenu = new InventoryMenu(this.inventory, !level.isClientSide, this);
		this.containerMenu = this.inventoryMenu;
		this.snapTo(pos.getX() + 0.5, pos.getY() + 1, pos.getZ() + 0.5, yRot, 0.0F);
	}

	@Override
	protected EntityEquipment createEquipment() {
		return new PlayerEquipment(this);
	}

	public boolean blockActionRestricted(Level level, BlockPos pos, GameType gameMode) {
		if (!gameMode.isBlockPlacingRestricted()) {
			return false;
		} else if (gameMode == GameType.SPECTATOR) {
			return true;
		} else if (this.mayBuild()) {
			return false;
		} else {
			ItemStack itemStack = this.getMainHandItem();
			return itemStack.isEmpty() || !itemStack.canBreakBlockInAdventureMode(new BlockInWorld(level, pos, false));
		}
	}

	public static Builder createAttributes() {
		return LivingEntity.createLivingAttributes()
			.add(Attributes.ATTACK_DAMAGE, 1.0)
			.add(Attributes.MOVEMENT_SPEED, 0.1F)
			.add(Attributes.ATTACK_SPEED)
			.add(Attributes.LUCK)
			.add(Attributes.BLOCK_INTERACTION_RANGE, 4.5)
			.add(Attributes.ENTITY_INTERACTION_RANGE, 3.0)
			.add(Attributes.BLOCK_BREAK_SPEED)
			.add(Attributes.SUBMERGED_MINING_SPEED)
			.add(Attributes.SNEAKING_SPEED)
			.add(Attributes.MINING_EFFICIENCY)
			.add(Attributes.SWEEPING_DAMAGE_RATIO);
	}

	@Override
	protected void defineSynchedData(net.minecraft.network.syncher.SynchedEntityData.Builder builder) {
		super.defineSynchedData(builder);
		builder.define(DATA_PLAYER_ABSORPTION_ID, 0.0F);
		builder.define(DATA_SCORE_ID, 0);
		builder.define(DATA_PLAYER_MODE_CUSTOMISATION, (byte)0);
		builder.define(DATA_PLAYER_MAIN_HAND, (byte)DEFAULT_MAIN_HAND.getId());
		builder.define(DATA_SHOULDER_LEFT, new CompoundTag());
		builder.define(DATA_SHOULDER_RIGHT, new CompoundTag());
	}

	@Override
	public void tick() {
		this.noPhysics = this.isSpectator();
		if (this.isSpectator() || this.isPassenger()) {
			this.setOnGround(false);
		}

		if (this.takeXpDelay > 0) {
			this.takeXpDelay--;
		}

		if (this.isSleeping()) {
			this.sleepCounter++;
			if (this.sleepCounter > 100) {
				this.sleepCounter = 100;
			}

			if (!this.level().isClientSide && this.level().isBrightOutside()) {
				this.stopSleepInBed(false, true);
			}
		} else if (this.sleepCounter > 0) {
			this.sleepCounter++;
			if (this.sleepCounter >= 110) {
				this.sleepCounter = 0;
			}
		}

		this.updateIsUnderwater();
		super.tick();
		if (!this.level().isClientSide && this.containerMenu != null && !this.containerMenu.stillValid(this)) {
			this.closeContainer();
			this.containerMenu = this.inventoryMenu;
		}

		this.moveCloak();
		if (this instanceof ServerPlayer serverPlayer) {
			this.foodData.tick(serverPlayer);
			this.awardStat(Stats.PLAY_TIME);
			this.awardStat(Stats.TOTAL_WORLD_TIME);
			if (this.isAlive()) {
				this.awardStat(Stats.TIME_SINCE_DEATH);
			}

			if (this.isDiscrete()) {
				this.awardStat(Stats.CROUCH_TIME);
			}

			if (!this.isSleeping()) {
				this.awardStat(Stats.TIME_SINCE_REST);
			}
		}

		int i = 29999999;
		double d = Mth.clamp(this.getX(), -2.9999999E7, 2.9999999E7);
		double e = Mth.clamp(this.getZ(), -2.9999999E7, 2.9999999E7);
		if (d != this.getX() || e != this.getZ()) {
			this.setPos(d, this.getY(), e);
		}

		this.attackStrengthTicker++;
		ItemStack itemStack = this.getMainHandItem();
		if (!ItemStack.matches(this.lastItemInMainHand, itemStack)) {
			if (!ItemStack.isSameItem(this.lastItemInMainHand, itemStack)) {
				this.resetAttackStrengthTicker();
			}

			this.lastItemInMainHand = itemStack.copy();
		}

		if (!this.isEyeInFluid(FluidTags.WATER) && this.isEquipped(Items.TURTLE_HELMET)) {
			this.turtleHelmetTick();
		}

		this.cooldowns.tick();
		this.updatePlayerPose();
		if (this.currentImpulseContextResetGraceTime > 0) {
			this.currentImpulseContextResetGraceTime--;
		}
	}

	@Override
	protected float getMaxHeadRotationRelativeToBody() {
		return this.isBlocking() ? 15.0F : super.getMaxHeadRotationRelativeToBody();
	}

	public boolean isSecondaryUseActive() {
		return this.isShiftKeyDown();
	}

	protected boolean wantsToStopRiding() {
		return this.isShiftKeyDown();
	}

	protected boolean isStayingOnGroundSurface() {
		return this.isShiftKeyDown();
	}

	protected boolean updateIsUnderwater() {
		this.wasUnderwater = this.isEyeInFluid(FluidTags.WATER);
		return this.wasUnderwater;
	}

	@Override
	public void onAboveBubbleColumn(boolean downwards, BlockPos pos) {
		if (!this.getAbilities().flying) {
			super.onAboveBubbleColumn(downwards, pos);
		}
	}

	@Override
	public void onInsideBubbleColumn(boolean downwards) {
		if (!this.getAbilities().flying) {
			super.onInsideBubbleColumn(downwards);
		}
	}

	private void turtleHelmetTick() {
		this.addEffect(new MobEffectInstance(MobEffects.WATER_BREATHING, 200, 0, false, false, true));
	}

	private boolean isEquipped(Item item) {
		for (EquipmentSlot equipmentSlot : EquipmentSlot.VALUES) {
			ItemStack itemStack = this.getItemBySlot(equipmentSlot);
			Equippable equippable = itemStack.get(DataComponents.EQUIPPABLE);
			if (itemStack.is(item) && equippable != null && equippable.slot() == equipmentSlot) {
				return true;
			}
		}

		return false;
	}

	protected ItemCooldowns createItemCooldowns() {
		return new ItemCooldowns();
	}

	private void moveCloak() {
		this.xCloakO = this.xCloak;
		this.yCloakO = this.yCloak;
		this.zCloakO = this.zCloak;
		double d = this.getX() - this.xCloak;
		double e = this.getY() - this.yCloak;
		double f = this.getZ() - this.zCloak;
		double g = 10.0;
		if (d > 10.0) {
			this.xCloak = this.getX();
			this.xCloakO = this.xCloak;
		}

		if (f > 10.0) {
			this.zCloak = this.getZ();
			this.zCloakO = this.zCloak;
		}

		if (e > 10.0) {
			this.yCloak = this.getY();
			this.yCloakO = this.yCloak;
		}

		if (d < -10.0) {
			this.xCloak = this.getX();
			this.xCloakO = this.xCloak;
		}

		if (f < -10.0) {
			this.zCloak = this.getZ();
			this.zCloakO = this.zCloak;
		}

		if (e < -10.0) {
			this.yCloak = this.getY();
			this.yCloakO = this.yCloak;
		}

		this.xCloak += d * 0.25;
		this.zCloak += f * 0.25;
		this.yCloak += e * 0.25;
	}

	protected void updatePlayerPose() {
		if (this.canPlayerFitWithinBlocksAndEntitiesWhen(Pose.SWIMMING)) {
			Pose pose = this.getDesiredPose();
			Pose pose2;
			if (this.isSpectator() || this.isPassenger() || this.canPlayerFitWithinBlocksAndEntitiesWhen(pose)) {
				pose2 = pose;
			} else if (this.canPlayerFitWithinBlocksAndEntitiesWhen(Pose.CROUCHING)) {
				pose2 = Pose.CROUCHING;
			} else {
				pose2 = Pose.SWIMMING;
			}

			this.setPose(pose2);
		}
	}

	private Pose getDesiredPose() {
		if (this.isSleeping()) {
			return Pose.SLEEPING;
		} else if (this.isSwimming()) {
			return Pose.SWIMMING;
		} else if (this.isFallFlying()) {
			return Pose.FALL_FLYING;
		} else if (this.isAutoSpinAttack()) {
			return Pose.SPIN_ATTACK;
		} else {
			return this.isShiftKeyDown() && !this.abilities.flying ? Pose.CROUCHING : Pose.STANDING;
		}
	}

	protected boolean canPlayerFitWithinBlocksAndEntitiesWhen(Pose pose) {
		return this.level().noCollision(this, this.getDimensions(pose).makeBoundingBox(this.position()).deflate(1.0E-7));
	}

	@Override
	protected SoundEvent getSwimSound() {
		return SoundEvents.PLAYER_SWIM;
	}

	@Override
	protected SoundEvent getSwimSplashSound() {
		return SoundEvents.PLAYER_SPLASH;
	}

	@Override
	protected SoundEvent getSwimHighSpeedSplashSound() {
		return SoundEvents.PLAYER_SPLASH_HIGH_SPEED;
	}

	@Override
	public int getDimensionChangingDelay() {
		return 10;
	}

	@Override
	public void playSound(SoundEvent sound, float volume, float pitch) {
		this.level().playSound(this, this.getX(), this.getY(), this.getZ(), sound, this.getSoundSource(), volume, pitch);
	}

	public void playNotifySound(SoundEvent sound, SoundSource source, float volume, float pitch) {
	}

	@Override
	public SoundSource getSoundSource() {
		return SoundSource.PLAYERS;
	}

	@Override
	protected int getFireImmuneTicks() {
		return 20;
	}

	@Override
	public void handleEntityEvent(byte id) {
		if (id == 9) {
			this.completeUsingItem();
		} else if (id == 23) {
			this.reducedDebugInfo = false;
		} else if (id == 22) {
			this.reducedDebugInfo = true;
		} else {
			super.handleEntityEvent(id);
		}
	}

	/**
	 * Sets the current crafting inventory back to the 2x2 square.
	 */
	protected void closeContainer() {
		this.containerMenu = this.inventoryMenu;
	}

	protected void doCloseContainer() {
	}

	@Override
	public void rideTick() {
		if (!this.level().isClientSide && this.wantsToStopRiding() && this.isPassenger()) {
			this.stopRiding();
			this.setShiftKeyDown(false);
		} else {
			super.rideTick();
			this.oBob = this.bob;
			this.bob = 0.0F;
		}
	}

	@Override
	public void aiStep() {
		if (this.jumpTriggerTime > 0) {
			this.jumpTriggerTime--;
		}

		this.tickRegeneration();
		this.inventory.tick();
		this.oBob = this.bob;
		if (this.abilities.flying && !this.isPassenger()) {
			this.resetFallDistance();
		}

		super.aiStep();
		this.updateSwingTime();
		this.yHeadRot = this.getYRot();
		this.setSpeed((float)this.getAttributeValue(Attributes.MOVEMENT_SPEED));
		float f;
		if (this.onGround() && !this.isDeadOrDying() && !this.isSwimming()) {
			f = Math.min(0.1F, (float)this.getDeltaMovement().horizontalDistance());
		} else {
			f = 0.0F;
		}

		this.bob = this.bob + (f - this.bob) * 0.4F;
		if (this.getHealth() > 0.0F && !this.isSpectator()) {
			AABB aABB;
			if (this.isPassenger() && !this.getVehicle().isRemoved()) {
				aABB = this.getBoundingBox().minmax(this.getVehicle().getBoundingBox()).inflate(1.0, 0.0, 1.0);
			} else {
				aABB = this.getBoundingBox().inflate(1.0, 0.5, 1.0);
			}

			List<Entity> list = this.level().getEntities(this, aABB);
			List<Entity> list2 = Lists.<Entity>newArrayList();

			for (Entity entity : list) {
				if (entity.getType() == EntityType.EXPERIENCE_ORB) {
					list2.add(entity);
				} else if (!entity.isRemoved()) {
					this.touch(entity);
				}
			}

			if (!list2.isEmpty()) {
				this.touch(Util.getRandom(list2, this.random));
			}
		}

		this.playShoulderEntityAmbientSound(this.getShoulderEntityLeft());
		this.playShoulderEntityAmbientSound(this.getShoulderEntityRight());
		if (!this.level().isClientSide && (this.fallDistance > 0.5 || this.isInWater()) || this.abilities.flying || this.isSleeping() || this.isInPowderSnow) {
			this.removeEntitiesOnShoulder();
		}
	}

	protected void tickRegeneration() {
	}

	private void playShoulderEntityAmbientSound(CompoundTag entityCompound) {
		if (!entityCompound.isEmpty() && !entityCompound.getBooleanOr("Silent", false)) {
			if (this.level().random.nextInt(200) == 0) {
				EntityType<?> entityType = (EntityType<?>)entityCompound.read("id", EntityType.CODEC).orElse(null);
				if (entityType == EntityType.PARROT && !Parrot.imitateNearbyMobs(this.level(), this)) {
					this.level()
						.playSound(
							null,
							this.getX(),
							this.getY(),
							this.getZ(),
							Parrot.getAmbient(this.level(), this.level().random),
							this.getSoundSource(),
							1.0F,
							Parrot.getPitch(this.level().random)
						);
				}
			}
		}
	}

	private void touch(Entity entity) {
		entity.playerTouch(this);
	}

	public int getScore() {
		return this.entityData.get(DATA_SCORE_ID);
	}

	/**
	 * Set player's score
	 */
	public void setScore(int score) {
		this.entityData.set(DATA_SCORE_ID, score);
	}

	/**
	 * Add to player's score
	 */
	public void increaseScore(int score) {
		int i = this.getScore();
		this.entityData.set(DATA_SCORE_ID, i + score);
	}

	public void startAutoSpinAttack(int ticks, float damage, ItemStack itemStack) {
		this.autoSpinAttackTicks = ticks;
		this.autoSpinAttackDmg = damage;
		this.autoSpinAttackItemStack = itemStack;
		if (!this.level().isClientSide) {
			this.removeEntitiesOnShoulder();
			this.setLivingEntityFlag(4, true);
		}
	}

	@NotNull
	@Override
	public ItemStack getWeaponItem() {
		return this.isAutoSpinAttack() && this.autoSpinAttackItemStack != null ? this.autoSpinAttackItemStack : super.getWeaponItem();
	}

	@Override
	public void die(DamageSource damageSource) {
		super.die(damageSource);
		this.reapplyPosition();
		if (!this.isSpectator() && this.level() instanceof ServerLevel serverLevel) {
			this.dropAllDeathLoot(serverLevel, damageSource);
		}

		if (damageSource != null) {
			this.setDeltaMovement(
				-Mth.cos((this.getHurtDir() + this.getYRot()) * (float) (Math.PI / 180.0)) * 0.1F,
				0.1F,
				-Mth.sin((this.getHurtDir() + this.getYRot()) * (float) (Math.PI / 180.0)) * 0.1F
			);
		} else {
			this.setDeltaMovement(0.0, 0.1, 0.0);
		}

		this.awardStat(Stats.DEATHS);
		this.resetStat(Stats.CUSTOM.get(Stats.TIME_SINCE_DEATH));
		this.resetStat(Stats.CUSTOM.get(Stats.TIME_SINCE_REST));
		this.clearFire();
		this.setSharedFlagOnFire(false);
		this.setLastDeathLocation(Optional.of(GlobalPos.of(this.level().dimension(), this.blockPosition())));
	}

	@Override
	protected void dropEquipment(ServerLevel level) {
		super.dropEquipment(level);
		if (!level.getGameRules().getBoolean(GameRules.RULE_KEEPINVENTORY)) {
			this.destroyVanishingCursedItems();
			this.inventory.dropAll();
		}
	}

	protected void destroyVanishingCursedItems() {
		for (int i = 0; i < this.inventory.getContainerSize(); i++) {
			ItemStack itemStack = this.inventory.getItem(i);
			if (!itemStack.isEmpty() && EnchantmentHelper.has(itemStack, EnchantmentEffectComponents.PREVENT_EQUIPMENT_DROP)) {
				this.inventory.removeItemNoUpdate(i);
			}
		}
	}

	@Override
	protected SoundEvent getHurtSound(DamageSource damageSource) {
		return damageSource.type().effects().sound();
	}

	@Override
	protected SoundEvent getDeathSound() {
		return SoundEvents.PLAYER_DEATH;
	}

	public void handleCreativeModeItemDrop(ItemStack stack) {
	}

	/**
	 * Drops an item into the world.
	 */
	@Nullable
	public ItemEntity drop(ItemStack itemStack, boolean includeThrowerName) {
		return this.drop(itemStack, false, includeThrowerName);
	}

	public float getDestroySpeed(BlockState state) {
		float f = this.inventory.getSelectedItem().getDestroySpeed(state);
		if (f > 1.0F) {
			f += (float)this.getAttributeValue(Attributes.MINING_EFFICIENCY);
		}

		if (MobEffectUtil.hasDigSpeed(this)) {
			f *= 1.0F + (MobEffectUtil.getDigSpeedAmplification(this) + 1) * 0.2F;
		}

		if (this.hasEffect(MobEffects.MINING_FATIGUE)) {
			float g = switch (this.getEffect(MobEffects.MINING_FATIGUE).getAmplifier()) {
				case 0 -> 0.3F;
				case 1 -> 0.09F;
				case 2 -> 0.0027F;
				default -> 8.1E-4F;
			};
			f *= g;
		}

		f *= (float)this.getAttributeValue(Attributes.BLOCK_BREAK_SPEED);
		if (this.isEyeInFluid(FluidTags.WATER)) {
			f *= (float)this.getAttribute(Attributes.SUBMERGED_MINING_SPEED).getValue();
		}

		if (!this.onGround()) {
			f /= 5.0F;
		}

		return f;
	}

	public boolean hasCorrectToolForDrops(BlockState state) {
		return !state.requiresCorrectToolForDrops() || this.inventory.getSelectedItem().isCorrectToolForDrops(state);
	}

	@Override
	public void readAdditionalSaveData(CompoundTag tag) {
		super.readAdditionalSaveData(tag);
		this.setUUID(this.gameProfile.getId());
		ListTag listTag = tag.getListOrEmpty("Inventory");
		this.inventory.load(listTag);
		this.inventory.setSelectedSlot(tag.getIntOr("SelectedItemSlot", 0));
		this.sleepCounter = tag.getShortOr("SleepTimer", (short)0);
		this.experienceProgress = tag.getFloatOr("XpP", 0.0F);
		this.experienceLevel = tag.getIntOr("XpLevel", 0);
		this.totalExperience = tag.getIntOr("XpTotal", 0);
		this.enchantmentSeed = tag.getIntOr("XpSeed", 0);
		if (this.enchantmentSeed == 0) {
			this.enchantmentSeed = this.random.nextInt();
		}

		this.setScore(tag.getIntOr("Score", 0));
		this.foodData.readAdditionalSaveData(tag);
		this.abilities.loadSaveData(tag);
		this.getAttribute(Attributes.MOVEMENT_SPEED).setBaseValue(this.abilities.getWalkingSpeed());
		tag.getList("EnderItems").ifPresent(listTagx -> this.enderChestInventory.fromTag(listTagx, this.registryAccess()));
		this.setShoulderEntityLeft(tag.getCompoundOrEmpty("ShoulderEntityLeft"));
		this.setShoulderEntityRight(tag.getCompoundOrEmpty("ShoulderEntityRight"));
		this.setLastDeathLocation(tag.read("LastDeathLocation", GlobalPos.CODEC));
		this.currentImpulseImpactPos = (Vec3)tag.read("current_explosion_impact_pos", Vec3.CODEC).orElse(null);
		this.ignoreFallDamageFromCurrentImpulse = tag.getBooleanOr("ignore_fall_damage_from_current_explosion", false);
		this.currentImpulseContextResetGraceTime = tag.getIntOr("current_impulse_context_reset_grace_time", 0);
	}

	@Override
	public void addAdditionalSaveData(CompoundTag tag) {
		super.addAdditionalSaveData(tag);
		NbtUtils.addCurrentDataVersion(tag);
		tag.put("Inventory", this.inventory.save(new ListTag()));
		tag.putInt("SelectedItemSlot", this.inventory.getSelectedSlot());
		tag.putShort("SleepTimer", (short)this.sleepCounter);
		tag.putFloat("XpP", this.experienceProgress);
		tag.putInt("XpLevel", this.experienceLevel);
		tag.putInt("XpTotal", this.totalExperience);
		tag.putInt("XpSeed", this.enchantmentSeed);
		tag.putInt("Score", this.getScore());
		this.foodData.addAdditionalSaveData(tag);
		this.abilities.addSaveData(tag);
		tag.put("EnderItems", this.enderChestInventory.createTag(this.registryAccess()));
		if (!this.getShoulderEntityLeft().isEmpty()) {
			tag.put("ShoulderEntityLeft", this.getShoulderEntityLeft());
		}

		if (!this.getShoulderEntityRight().isEmpty()) {
			tag.put("ShoulderEntityRight", this.getShoulderEntityRight());
		}

		this.lastDeathLocation.ifPresent(globalPos -> tag.store("LastDeathLocation", GlobalPos.CODEC, globalPos));
		tag.storeNullable("current_explosion_impact_pos", Vec3.CODEC, this.currentImpulseImpactPos);
		tag.putBoolean("ignore_fall_damage_from_current_explosion", this.ignoreFallDamageFromCurrentImpulse);
		tag.putInt("current_impulse_context_reset_grace_time", this.currentImpulseContextResetGraceTime);
	}

	@Override
	public boolean isInvulnerableTo(ServerLevel level, DamageSource damageSource) {
		if (super.isInvulnerableTo(level, damageSource)) {
			return true;
		} else if (damageSource.is(DamageTypeTags.IS_DROWNING)) {
			return !level.getGameRules().getBoolean(GameRules.RULE_DROWNING_DAMAGE);
		} else if (damageSource.is(DamageTypeTags.IS_FALL)) {
			return !level.getGameRules().getBoolean(GameRules.RULE_FALL_DAMAGE);
		} else if (damageSource.is(DamageTypeTags.IS_FIRE)) {
			return !level.getGameRules().getBoolean(GameRules.RULE_FIRE_DAMAGE);
		} else {
			return damageSource.is(DamageTypeTags.IS_FREEZING) ? !level.getGameRules().getBoolean(GameRules.RULE_FREEZE_DAMAGE) : false;
		}
	}

	@Override
	public boolean hurtServer(ServerLevel level, DamageSource damageSource, float amount) {
		if (this.isInvulnerableTo(level, damageSource)) {
			return false;
		} else if (this.abilities.invulnerable && !damageSource.is(DamageTypeTags.BYPASSES_INVULNERABILITY)) {
			return false;
		} else {
			this.noActionTime = 0;
			if (this.isDeadOrDying()) {
				return false;
			} else {
				this.removeEntitiesOnShoulder();
				if (damageSource.scalesWithDifficulty()) {
					if (level.getDifficulty() == Difficulty.PEACEFUL) {
						amount = 0.0F;
					}

					if (level.getDifficulty() == Difficulty.EASY) {
						amount = Math.min(amount / 2.0F + 1.0F, amount);
					}

					if (level.getDifficulty() == Difficulty.HARD) {
						amount = amount * 3.0F / 2.0F;
					}
				}

				return amount == 0.0F ? false : super.hurtServer(level, damageSource, amount);
			}
		}
	}

	@Override
	protected void blockUsingItem(ServerLevel level, LivingEntity entity) {
		super.blockUsingItem(level, entity);
		ItemStack itemStack = this.getItemBlockingWith();
		BlocksAttacks blocksAttacks = itemStack != null ? itemStack.get(DataComponents.BLOCKS_ATTACKS) : null;
		float f = entity.getSecondsToDisableBlocking();
		if (f > 0.0F && blocksAttacks != null) {
			blocksAttacks.disable(level, this, f, itemStack);
		}
	}

	@Override
	public boolean canBeSeenAsEnemy() {
		return !this.getAbilities().invulnerable && super.canBeSeenAsEnemy();
	}

	public boolean canHarmPlayer(Player other) {
		Team team = this.getTeam();
		Team team2 = other.getTeam();
		if (team == null) {
			return true;
		} else {
			return !team.isAlliedTo(team2) ? true : team.isAllowFriendlyFire();
		}
	}

	@Override
	protected void hurtArmor(DamageSource damageSource, float damageAmount) {
		this.doHurtEquipment(damageSource, damageAmount, new EquipmentSlot[]{EquipmentSlot.FEET, EquipmentSlot.LEGS, EquipmentSlot.CHEST, EquipmentSlot.HEAD});
	}

	@Override
	protected void hurtHelmet(DamageSource damageSource, float damageAmount) {
		this.doHurtEquipment(damageSource, damageAmount, new EquipmentSlot[]{EquipmentSlot.HEAD});
	}

	@Override
	protected void actuallyHurt(ServerLevel level, DamageSource damageSource, float amount) {
		if (!this.isInvulnerableTo(level, damageSource)) {
			amount = this.getDamageAfterArmorAbsorb(damageSource, amount);
			amount = this.getDamageAfterMagicAbsorb(damageSource, amount);
			float var8 = Math.max(amount - this.getAbsorptionAmount(), 0.0F);
			this.setAbsorptionAmount(this.getAbsorptionAmount() - (amount - var8));
			float g = amount - var8;
			if (g > 0.0F && g < 3.4028235E37F) {
				this.awardStat(Stats.DAMAGE_ABSORBED, Math.round(g * 10.0F));
			}

			if (var8 != 0.0F) {
				this.causeFoodExhaustion(damageSource.getFoodExhaustion());
				this.getCombatTracker().recordDamage(damageSource, var8);
				this.setHealth(this.getHealth() - var8);
				if (var8 < 3.4028235E37F) {
					this.awardStat(Stats.DAMAGE_TAKEN, Math.round(var8 * 10.0F));
				}

				this.gameEvent(GameEvent.ENTITY_DAMAGE);
			}
		}
	}

	public boolean isTextFilteringEnabled() {
		return false;
	}

	public void openTextEdit(SignBlockEntity signEntity, boolean isFrontText) {
	}

	public void openMinecartCommandBlock(BaseCommandBlock commandEntity) {
	}

	public void openCommandBlock(CommandBlockEntity commandBlockEntity) {
	}

	public void openStructureBlock(StructureBlockEntity structureEntity) {
	}

	public void openTestBlock(TestBlockEntity testBlockEntity) {
	}

	public void openTestInstanceBlock(TestInstanceBlockEntity testInstanceBlockEntity) {
	}

	public void openJigsawBlock(JigsawBlockEntity jigsawBlockEntity) {
	}

	public void openHorseInventory(AbstractHorse horse, Container inventory) {
	}

	public OptionalInt openMenu(@Nullable MenuProvider menu) {
		return OptionalInt.empty();
	}

	public void sendMerchantOffers(int containerId, MerchantOffers offers, int villagerLevel, int villagerXp, boolean showProgress, boolean canRestock) {
	}

	public void openItemGui(ItemStack stack, InteractionHand hand) {
	}

	public InteractionResult interactOn(Entity entityToInteractOn, InteractionHand hand) {
		if (this.isSpectator()) {
			if (entityToInteractOn instanceof MenuProvider) {
				this.openMenu((MenuProvider)entityToInteractOn);
			}

			return InteractionResult.PASS;
		} else {
			ItemStack itemStack = this.getItemInHand(hand);
			ItemStack itemStack2 = itemStack.copy();
			InteractionResult interactionResult = entityToInteractOn.interact(this, hand);
			if (interactionResult.consumesAction()) {
				if (this.hasInfiniteMaterials() && itemStack == this.getItemInHand(hand) && itemStack.getCount() < itemStack2.getCount()) {
					itemStack.setCount(itemStack2.getCount());
				}

				return interactionResult;
			} else {
				if (!itemStack.isEmpty() && entityToInteractOn instanceof LivingEntity) {
					if (this.hasInfiniteMaterials()) {
						itemStack = itemStack2;
					}

					InteractionResult interactionResult2 = itemStack.interactLivingEntity(this, (LivingEntity)entityToInteractOn, hand);
					if (interactionResult2.consumesAction()) {
						this.level().gameEvent(GameEvent.ENTITY_INTERACT, entityToInteractOn.position(), Context.of(this));
						if (itemStack.isEmpty() && !this.hasInfiniteMaterials()) {
							this.setItemInHand(hand, ItemStack.EMPTY);
						}

						return interactionResult2;
					}
				}

				return InteractionResult.PASS;
			}
		}
	}

	@Override
	public void removeVehicle() {
		super.removeVehicle();
		this.boardingCooldown = 0;
	}

	@Override
	protected boolean isImmobile() {
		return super.isImmobile() || this.isSleeping();
	}

	@Override
	public boolean isAffectedByFluids() {
		return !this.abilities.flying;
	}

	@Override
	protected Vec3 maybeBackOffFromEdge(Vec3 vec, MoverType mover) {
		float f = this.maxUpStep();
		if (!this.abilities.flying
			&& !(vec.y > 0.0)
			&& (mover == MoverType.SELF || mover == MoverType.PLAYER)
			&& this.isStayingOnGroundSurface()
			&& this.isAboveGround(f)) {
			double d = vec.x;
			double e = vec.z;
			double g = 0.05;
			double h = Math.signum(d) * 0.05;

			double i;
			for (i = Math.signum(e) * 0.05; d != 0.0 && this.canFallAtLeast(d, 0.0, f); d -= h) {
				if (Math.abs(d) <= 0.05) {
					d = 0.0;
					break;
				}
			}

			while (e != 0.0 && this.canFallAtLeast(0.0, e, f)) {
				if (Math.abs(e) <= 0.05) {
					e = 0.0;
					break;
				}

				e -= i;
			}

			while (d != 0.0 && e != 0.0 && this.canFallAtLeast(d, e, f)) {
				if (Math.abs(d) <= 0.05) {
					d = 0.0;
				} else {
					d -= h;
				}

				if (Math.abs(e) <= 0.05) {
					e = 0.0;
				} else {
					e -= i;
				}
			}

			return new Vec3(d, vec.y, e);
		} else {
			return vec;
		}
	}

	private boolean isAboveGround(float maxUpStep) {
		return this.onGround() || this.fallDistance < maxUpStep && !this.canFallAtLeast(0.0, 0.0, maxUpStep - this.fallDistance);
	}

	private boolean canFallAtLeast(double x, double z, double distance) {
		AABB aABB = this.getBoundingBox();
		return this.level()
			.noCollision(
				this, new AABB(aABB.minX + 1.0E-7 + x, aABB.minY - distance - 1.0E-7, aABB.minZ + 1.0E-7 + z, aABB.maxX - 1.0E-7 + x, aABB.minY, aABB.maxZ - 1.0E-7 + z)
			);
	}

	/**
	 * Attacks for the player the targeted entity with the currently equipped item.  The equipped item has hitEntity called on it. Args: targetEntity
	 */
	public void attack(Entity target) {
		if (target.isAttackable()) {
			if (!target.skipAttackInteraction(this)) {
				float f = this.isAutoSpinAttack() ? this.autoSpinAttackDmg : (float)this.getAttributeValue(Attributes.ATTACK_DAMAGE);
				ItemStack itemStack = this.getWeaponItem();
				DamageSource damageSource = (DamageSource)Optional.ofNullable(itemStack.getItem().getDamageSource(this)).orElse(this.damageSources().playerAttack(this));
				float g = this.getEnchantedDamage(target, f, damageSource) - f;
				float h = this.getAttackStrengthScale(0.5F);
				f *= 0.2F + h * h * 0.8F;
				g *= h;
				this.resetAttackStrengthTicker();
				if (target.getType().is(EntityTypeTags.REDIRECTABLE_PROJECTILE)
					&& target instanceof Projectile projectile
					&& projectile.deflect(ProjectileDeflection.AIM_DEFLECT, this, this, true)) {
					this.level().playSound(null, this.getX(), this.getY(), this.getZ(), SoundEvents.PLAYER_ATTACK_NODAMAGE, this.getSoundSource());
				} else {
					if (f > 0.0F || g > 0.0F) {
						boolean bl = h > 0.9F;
						boolean bl2;
						if (this.isSprinting() && bl) {
							this.level().playSound(null, this.getX(), this.getY(), this.getZ(), SoundEvents.PLAYER_ATTACK_KNOCKBACK, this.getSoundSource(), 1.0F, 1.0F);
							bl2 = true;
						} else {
							bl2 = false;
						}

						f += itemStack.getItem().getAttackDamageBonus(target, f, damageSource);
						boolean bl3 = bl
							&& this.fallDistance > 0.0
							&& !this.onGround()
							&& !this.onClimbable()
							&& !this.isInWater()
							&& !this.hasEffect(MobEffects.BLINDNESS)
							&& !this.isPassenger()
							&& target instanceof LivingEntity
							&& !this.isSprinting();
						if (bl3) {
							f *= 1.5F;
						}

						float i = f + g;
						boolean bl4 = false;
						if (bl && !bl3 && !bl2 && this.onGround()) {
							double d = this.getKnownMovement().horizontalDistanceSqr();
							double e = this.getSpeed() * 2.5;
							if (d < Mth.square(e) && this.getItemInHand(InteractionHand.MAIN_HAND).is(ItemTags.SWORDS)) {
								bl4 = true;
							}
						}

						float j = 0.0F;
						if (target instanceof LivingEntity livingEntity) {
							j = livingEntity.getHealth();
						}

						Vec3 vec3 = target.getDeltaMovement();
						boolean bl5 = target.hurtOrSimulate(damageSource, i);
						if (bl5) {
							float k = this.getKnockback(target, damageSource) + (bl2 ? 1.0F : 0.0F);
							if (k > 0.0F) {
								if (target instanceof LivingEntity livingEntity2) {
									livingEntity2.knockback(k * 0.5F, Mth.sin(this.getYRot() * (float) (Math.PI / 180.0)), -Mth.cos(this.getYRot() * (float) (Math.PI / 180.0)));
								} else {
									target.push(-Mth.sin(this.getYRot() * (float) (Math.PI / 180.0)) * k * 0.5F, 0.1, Mth.cos(this.getYRot() * (float) (Math.PI / 180.0)) * k * 0.5F);
								}

								this.setDeltaMovement(this.getDeltaMovement().multiply(0.6, 1.0, 0.6));
								this.setSprinting(false);
							}

							if (bl4) {
								float l = 1.0F + (float)this.getAttributeValue(Attributes.SWEEPING_DAMAGE_RATIO) * f;

								for (LivingEntity livingEntity3 : this.level().getEntitiesOfClass(LivingEntity.class, target.getBoundingBox().inflate(1.0, 0.25, 1.0))) {
									if (livingEntity3 != this
										&& livingEntity3 != target
										&& !this.isAlliedTo(livingEntity3)
										&& !(livingEntity3 instanceof ArmorStand armorStand && armorStand.isMarker())
										&& this.distanceToSqr(livingEntity3) < 9.0) {
										float m = this.getEnchantedDamage(livingEntity3, l, damageSource) * h;
										if (this.level() instanceof ServerLevel serverLevel && livingEntity3.hurtServer(serverLevel, damageSource, m)) {
											livingEntity3.knockback(0.4F, Mth.sin(this.getYRot() * (float) (Math.PI / 180.0)), -Mth.cos(this.getYRot() * (float) (Math.PI / 180.0)));
											EnchantmentHelper.doPostAttackEffects(serverLevel, livingEntity3, damageSource);
										}
									}
								}

								this.level().playSound(null, this.getX(), this.getY(), this.getZ(), SoundEvents.PLAYER_ATTACK_SWEEP, this.getSoundSource(), 1.0F, 1.0F);
								this.sweepAttack();
							}

							if (target instanceof ServerPlayer && target.hurtMarked) {
								((ServerPlayer)target).connection.send(new ClientboundSetEntityMotionPacket(target));
								target.hurtMarked = false;
								target.setDeltaMovement(vec3);
							}

							if (bl3) {
								this.level().playSound(null, this.getX(), this.getY(), this.getZ(), SoundEvents.PLAYER_ATTACK_CRIT, this.getSoundSource(), 1.0F, 1.0F);
								this.crit(target);
							}

							if (!bl3 && !bl4) {
								if (bl) {
									this.level().playSound(null, this.getX(), this.getY(), this.getZ(), SoundEvents.PLAYER_ATTACK_STRONG, this.getSoundSource(), 1.0F, 1.0F);
								} else {
									this.level().playSound(null, this.getX(), this.getY(), this.getZ(), SoundEvents.PLAYER_ATTACK_WEAK, this.getSoundSource(), 1.0F, 1.0F);
								}
							}

							if (g > 0.0F) {
								this.magicCrit(target);
							}

							this.setLastHurtMob(target);
							Entity entity = target;
							if (target instanceof EnderDragonPart) {
								entity = ((EnderDragonPart)target).parentMob;
							}

							boolean bl6 = false;
							if (this.level() instanceof ServerLevel serverLevel2) {
								if (entity instanceof LivingEntity livingEntity3x) {
									bl6 = itemStack.hurtEnemy(livingEntity3x, this);
								}

								EnchantmentHelper.doPostAttackEffects(serverLevel2, target, damageSource);
							}

							if (!this.level().isClientSide && !itemStack.isEmpty() && entity instanceof LivingEntity) {
								if (bl6) {
									itemStack.postHurtEnemy((LivingEntity)entity, this);
								}

								if (itemStack.isEmpty()) {
									if (itemStack == this.getMainHandItem()) {
										this.setItemInHand(InteractionHand.MAIN_HAND, ItemStack.EMPTY);
									} else {
										this.setItemInHand(InteractionHand.OFF_HAND, ItemStack.EMPTY);
									}
								}
							}

							if (target instanceof LivingEntity) {
								float n = j - ((LivingEntity)target).getHealth();
								this.awardStat(Stats.DAMAGE_DEALT, Math.round(n * 10.0F));
								if (this.level() instanceof ServerLevel && n > 2.0F) {
									int o = (int)(n * 0.5);
									((ServerLevel)this.level()).sendParticles(ParticleTypes.DAMAGE_INDICATOR, target.getX(), target.getY(0.5), target.getZ(), o, 0.1, 0.0, 0.1, 0.2);
								}
							}

							this.causeFoodExhaustion(0.1F);
						} else {
							this.level().playSound(null, this.getX(), this.getY(), this.getZ(), SoundEvents.PLAYER_ATTACK_NODAMAGE, this.getSoundSource(), 1.0F, 1.0F);
						}
					}
				}
			}
		}
	}

	protected float getEnchantedDamage(Entity entity, float damage, DamageSource damageSource) {
		return damage;
	}

	@Override
	protected void doAutoAttackOnTouch(LivingEntity target) {
		this.attack(target);
	}

	/**
	 * Called when the entity is dealt a critical hit.
	 */
	public void crit(Entity entityHit) {
	}

	public void magicCrit(Entity entityHit) {
	}

	public void sweepAttack() {
		double d = -Mth.sin(this.getYRot() * (float) (Math.PI / 180.0));
		double e = Mth.cos(this.getYRot() * (float) (Math.PI / 180.0));
		if (this.level() instanceof ServerLevel) {
			((ServerLevel)this.level()).sendParticles(ParticleTypes.SWEEP_ATTACK, this.getX() + d, this.getY(0.5), this.getZ() + e, 0, d, 0.0, e, 0.0);
		}
	}

	public void respawn() {
	}

	@Override
	public void remove(Entity.RemovalReason reason) {
		super.remove(reason);
		this.inventoryMenu.removed(this);
		if (this.containerMenu != null && this.hasContainerOpen()) {
			this.doCloseContainer();
		}
	}

	@Override
	public boolean isClientAuthoritative() {
		return true;
	}

	@Override
	protected boolean isLocalClientAuthoritative() {
		return this.isLocalPlayer();
	}

	/**
	 * Returns whether this is a {@link net.minecraft.client.player.LocalPlayer}.
	 */
	public boolean isLocalPlayer() {
		return false;
	}

	@Override
	public boolean canSimulateMovement() {
		return !this.level().isClientSide || this.isLocalPlayer();
	}

	@Override
	public boolean isEffectiveAi() {
		return !this.level().isClientSide || this.isLocalPlayer();
	}

	/**
	 * Returns the GameProfile for this player
	 */
	public GameProfile getGameProfile() {
		return this.gameProfile;
	}

	public Inventory getInventory() {
		return this.inventory;
	}

	public Abilities getAbilities() {
		return this.abilities;
	}

	@Override
	public boolean hasInfiniteMaterials() {
		return this.abilities.instabuild;
	}

	public boolean preventsBlockDrops() {
		return this.abilities.instabuild;
	}

	public void updateTutorialInventoryAction(ItemStack carried, ItemStack clicked, ClickAction action) {
	}

	public boolean hasContainerOpen() {
		return this.containerMenu != this.inventoryMenu;
	}

	public boolean canDropItems() {
		return true;
	}

	public Either<Player.BedSleepingProblem, Unit> startSleepInBed(BlockPos bedPos) {
		this.startSleeping(bedPos);
		this.sleepCounter = 0;
		return Either.right(Unit.INSTANCE);
	}

	public void stopSleepInBed(boolean wakeImmediately, boolean updateLevelForSleepingPlayers) {
		super.stopSleeping();
		if (this.level() instanceof ServerLevel && updateLevelForSleepingPlayers) {
			((ServerLevel)this.level()).updateSleepingPlayerList();
		}

		this.sleepCounter = wakeImmediately ? 0 : 100;
	}

	@Override
	public void stopSleeping() {
		this.stopSleepInBed(true, true);
	}

	/**
	 * Returns whether the player is asleep and the screen has fully faded.
	 */
	public boolean isSleepingLongEnough() {
		return this.isSleeping() && this.sleepCounter >= 100;
	}

	public int getSleepTimer() {
		return this.sleepCounter;
	}

	public void displayClientMessage(Component chatComponent, boolean actionBar) {
	}

	public void awardStat(ResourceLocation statKey) {
		this.awardStat(Stats.CUSTOM.get(statKey));
	}

	public void awardStat(ResourceLocation stat, int increment) {
		this.awardStat(Stats.CUSTOM.get(stat), increment);
	}

	/**
	 * Add a stat once
	 */
	public void awardStat(Stat<?> stat) {
		this.awardStat(stat, 1);
	}

	/**
	 * Adds a value to a statistic field.
	 */
	public void awardStat(Stat<?> stat, int increment) {
	}

	public void resetStat(Stat<?> stat) {
	}

	public int awardRecipes(Collection<RecipeHolder<?>> recipes) {
		return 0;
	}

	public void triggerRecipeCrafted(RecipeHolder<?> recipe, List<ItemStack> items) {
	}

	public void awardRecipesByKey(List<ResourceKey<Recipe<?>>> recipes) {
	}

	public int resetRecipes(Collection<RecipeHolder<?>> recipes) {
		return 0;
	}

	@Override
	public void travel(Vec3 travelVector) {
		if (this.isPassenger()) {
			super.travel(travelVector);
		} else {
			if (this.isSwimming()) {
				double d = this.getLookAngle().y;
				double e = d < -0.2 ? 0.085 : 0.06;
				if (d <= 0.0 || this.jumping || !this.level().getFluidState(BlockPos.containing(this.getX(), this.getY() + 1.0 - 0.1, this.getZ())).isEmpty()) {
					Vec3 vec3 = this.getDeltaMovement();
					this.setDeltaMovement(vec3.add(0.0, (d - vec3.y) * e, 0.0));
				}
			}

			if (this.getAbilities().flying) {
				double d = this.getDeltaMovement().y;
				super.travel(travelVector);
				this.setDeltaMovement(this.getDeltaMovement().with(Direction.Axis.Y, d * 0.6));
			} else {
				super.travel(travelVector);
			}
		}
	}

	@Override
	protected boolean canGlide() {
		return !this.abilities.flying && super.canGlide();
	}

	@Override
	public void updateSwimming() {
		if (this.abilities.flying) {
			this.setSwimming(false);
		} else {
			super.updateSwimming();
		}
	}

	protected boolean freeAt(BlockPos pos) {
		return !this.level().getBlockState(pos).isSuffocating(this.level(), pos);
	}

	@Override
	public float getSpeed() {
		return (float)this.getAttributeValue(Attributes.MOVEMENT_SPEED);
	}

	@Override
	public boolean causeFallDamage(double fallDistance, float damageMultiplier, DamageSource damageSource) {
		if (this.abilities.mayfly) {
			return false;
		} else {
			if (fallDistance >= 2.0) {
				this.awardStat(Stats.FALL_ONE_CM, (int)Math.round(fallDistance * 100.0));
			}

			boolean bl = this.currentImpulseImpactPos != null && this.ignoreFallDamageFromCurrentImpulse;
			double d;
			if (bl) {
				d = Math.min(fallDistance, this.currentImpulseImpactPos.y - this.getY());
				boolean bl2 = d <= 0.0;
				if (bl2) {
					this.resetCurrentImpulseContext();
				} else {
					this.tryResetCurrentImpulseContext();
				}
			} else {
				d = fallDistance;
			}

			if (d > 0.0 && super.causeFallDamage(d, damageMultiplier, damageSource)) {
				this.resetCurrentImpulseContext();
				return true;
			} else {
				this.propagateFallToPassengers(fallDistance, damageMultiplier, damageSource);
				return false;
			}
		}
	}

	public boolean tryToStartFallFlying() {
		if (!this.isFallFlying() && this.canGlide() && !this.isInWater()) {
			this.startFallFlying();
			return true;
		} else {
			return false;
		}
	}

	public void startFallFlying() {
		this.setSharedFlag(7, true);
	}

	@Override
	protected void doWaterSplashEffect() {
		if (!this.isSpectator()) {
			super.doWaterSplashEffect();
		}
	}

	@Override
	protected void playStepSound(BlockPos pos, BlockState state) {
		if (this.isInWater()) {
			this.waterSwimSound();
			this.playMuffledStepSound(state);
		} else {
			BlockPos blockPos = this.getPrimaryStepSoundBlockPos(pos);
			if (!pos.equals(blockPos)) {
				BlockState blockState = this.level().getBlockState(blockPos);
				if (blockState.is(BlockTags.COMBINATION_STEP_SOUND_BLOCKS)) {
					this.playCombinationStepSounds(blockState, state);
				} else {
					super.playStepSound(blockPos, blockState);
				}
			} else {
				super.playStepSound(pos, state);
			}
		}
	}

	@Override
	public LivingEntity.Fallsounds getFallSounds() {
		return new LivingEntity.Fallsounds(SoundEvents.PLAYER_SMALL_FALL, SoundEvents.PLAYER_BIG_FALL);
	}

	@Override
	public boolean killedEntity(ServerLevel level, LivingEntity entity) {
		this.awardStat(Stats.ENTITY_KILLED.get(entity.getType()));
		return true;
	}

	@Override
	public void makeStuckInBlock(BlockState state, Vec3 motionMultiplier) {
		if (!this.abilities.flying) {
			super.makeStuckInBlock(state, motionMultiplier);
		}

		this.tryResetCurrentImpulseContext();
	}

	public void giveExperiencePoints(int xpPoints) {
		this.increaseScore(xpPoints);
		this.experienceProgress = this.experienceProgress + (float)xpPoints / this.getXpNeededForNextLevel();
		this.totalExperience = Mth.clamp(this.totalExperience + xpPoints, 0, Integer.MAX_VALUE);

		while (this.experienceProgress < 0.0F) {
			float f = this.experienceProgress * this.getXpNeededForNextLevel();
			if (this.experienceLevel > 0) {
				this.giveExperienceLevels(-1);
				this.experienceProgress = 1.0F + f / this.getXpNeededForNextLevel();
			} else {
				this.giveExperienceLevels(-1);
				this.experienceProgress = 0.0F;
			}
		}

		while (this.experienceProgress >= 1.0F) {
			this.experienceProgress = (this.experienceProgress - 1.0F) * this.getXpNeededForNextLevel();
			this.giveExperienceLevels(1);
			this.experienceProgress = this.experienceProgress / this.getXpNeededForNextLevel();
		}
	}

	public int getEnchantmentSeed() {
		return this.enchantmentSeed;
	}

	public void onEnchantmentPerformed(ItemStack enchantedItem, int levelCost) {
		this.experienceLevel -= levelCost;
		if (this.experienceLevel < 0) {
			this.experienceLevel = 0;
			this.experienceProgress = 0.0F;
			this.totalExperience = 0;
		}

		this.enchantmentSeed = this.random.nextInt();
	}

	/**
	 * Add experience levels to this player.
	 */
	public void giveExperienceLevels(int levels) {
		this.experienceLevel = IntMath.saturatedAdd(this.experienceLevel, levels);
		if (this.experienceLevel < 0) {
			this.experienceLevel = 0;
			this.experienceProgress = 0.0F;
			this.totalExperience = 0;
		}

		if (levels > 0 && this.experienceLevel % 5 == 0 && this.lastLevelUpTime < this.tickCount - 100.0F) {
			float f = this.experienceLevel > 30 ? 1.0F : this.experienceLevel / 30.0F;
			this.level().playSound(null, this.getX(), this.getY(), this.getZ(), SoundEvents.PLAYER_LEVELUP, this.getSoundSource(), f * 0.75F, 1.0F);
			this.lastLevelUpTime = this.tickCount;
		}
	}

	/**
	 * This method returns the cap amount of experience that the experience bar can hold. With each level, the experience cap on the player's experience bar is raised by 10.
	 */
	public int getXpNeededForNextLevel() {
		if (this.experienceLevel >= 30) {
			return 112 + (this.experienceLevel - 30) * 9;
		} else {
			return this.experienceLevel >= 15 ? 37 + (this.experienceLevel - 15) * 5 : 7 + this.experienceLevel * 2;
		}
	}

	/**
	 * Increases exhaustion level by the supplied amount.
	 */
	public void causeFoodExhaustion(float exhaustion) {
		if (!this.abilities.invulnerable) {
			if (!this.level().isClientSide) {
				this.foodData.addExhaustion(exhaustion);
			}
		}
	}

	public Optional<WardenSpawnTracker> getWardenSpawnTracker() {
		return Optional.empty();
	}

	/**
	 * Returns the player's FoodStats object.
	 */
	public FoodData getFoodData() {
		return this.foodData;
	}

	public boolean canEat(boolean canAlwaysEat) {
		return this.abilities.invulnerable || canAlwaysEat || this.foodData.needsFood();
	}

	/**
	 * Checks if the player's health is not full and not zero.
	 */
	public boolean isHurt() {
		return this.getHealth() > 0.0F && this.getHealth() < this.getMaxHealth();
	}

	public boolean mayBuild() {
		return this.abilities.mayBuild;
	}

	/**
	 * Returns whether this player can modify the block at a certain location with the given stack.
	 * <p>
	 * The position being queried is {@code pos.offset(facing.getOpposite())}.
	 * 
	 * @return Whether this player may modify the queried location in the current world
	 * @see ItemStack#canPlaceOn(Block)
	 * @see ItemStack#canEditBlocks()
	 * @see PlayerCapabilities#allowEdit
	 */
	public boolean mayUseItemAt(BlockPos pos, Direction facing, ItemStack stack) {
		if (this.abilities.mayBuild) {
			return true;
		} else {
			BlockPos blockPos = pos.relative(facing.getOpposite());
			BlockInWorld blockInWorld = new BlockInWorld(this.level(), blockPos, false);
			return stack.canPlaceOnBlockInAdventureMode(blockInWorld);
		}
	}

	@Override
	protected int getBaseExperienceReward(ServerLevel level) {
		return !level.getGameRules().getBoolean(GameRules.RULE_KEEPINVENTORY) && !this.isSpectator() ? Math.min(this.experienceLevel * 7, 100) : 0;
	}

	@Override
	protected boolean isAlwaysExperienceDropper() {
		return true;
	}

	@Override
	public boolean shouldShowName() {
		return true;
	}

	@Override
	protected Entity.MovementEmission getMovementEmission() {
		return this.abilities.flying || this.onGround() && this.isDiscrete() ? Entity.MovementEmission.NONE : Entity.MovementEmission.ALL;
	}

	/**
	 * Sends the player's abilities to the server (if there is one).
	 */
	public void onUpdateAbilities() {
	}

	@Override
	public Component getName() {
		return Component.literal(this.gameProfile.getName());
	}

	/**
	 * Returns the InventoryEnderChest of this player.
	 */
	public PlayerEnderChestContainer getEnderChestInventory() {
		return this.enderChestInventory;
	}

	@Override
	protected boolean doesEmitEquipEvent(EquipmentSlot slot) {
		return slot.getType() == EquipmentSlot.Type.HUMANOID_ARMOR;
	}

	public boolean addItem(ItemStack stack) {
		return this.inventory.add(stack);
	}

	public boolean setEntityOnShoulder(CompoundTag entityCompound) {
		if (this.isPassenger() || !this.onGround() || this.isInWater() || this.isInPowderSnow) {
			return false;
		} else if (this.getShoulderEntityLeft().isEmpty()) {
			this.setShoulderEntityLeft(entityCompound);
			this.timeEntitySatOnShoulder = this.level().getGameTime();
			return true;
		} else if (this.getShoulderEntityRight().isEmpty()) {
			this.setShoulderEntityRight(entityCompound);
			this.timeEntitySatOnShoulder = this.level().getGameTime();
			return true;
		} else {
			return false;
		}
	}

	protected void removeEntitiesOnShoulder() {
		if (this.timeEntitySatOnShoulder + 20L < this.level().getGameTime()) {
			this.respawnEntityOnShoulder(this.getShoulderEntityLeft());
			this.setShoulderEntityLeft(new CompoundTag());
			this.respawnEntityOnShoulder(this.getShoulderEntityRight());
			this.setShoulderEntityRight(new CompoundTag());
		}
	}

	private void respawnEntityOnShoulder(CompoundTag entityCompound) {
		if (!this.level().isClientSide && !entityCompound.isEmpty()) {
			EntityType.create(entityCompound, this.level(), EntitySpawnReason.LOAD).ifPresent(entity -> {
				if (entity instanceof TamableAnimal tamableAnimal) {
					tamableAnimal.setOwner(this);
				}

				entity.setPos(this.getX(), this.getY() + 0.7F, this.getZ());
				((ServerLevel)this.level()).addWithUUID(entity);
			});
		}
	}

	@Nullable
	public abstract GameType gameMode();

	@Override
	public boolean isSpectator() {
		return this.gameMode() == GameType.SPECTATOR;
	}

	@Override
	public boolean canBeHitByProjectile() {
		return !this.isSpectator() && super.canBeHitByProjectile();
	}

	@Override
	public boolean isSwimming() {
		return !this.abilities.flying && !this.isSpectator() && super.isSwimming();
	}

	public boolean isCreative() {
		return this.gameMode() == GameType.CREATIVE;
	}

	@Override
	public boolean isPushedByFluid() {
		return !this.abilities.flying;
	}

	public Scoreboard getScoreboard() {
		return this.level().getScoreboard();
	}

	@Override
	public Component getDisplayName() {
		MutableComponent mutableComponent = PlayerTeam.formatNameForTeam(this.getTeam(), this.getName());
		return this.decorateDisplayNameComponent(mutableComponent);
	}

	private MutableComponent decorateDisplayNameComponent(MutableComponent displayName) {
		String string = this.getGameProfile().getName();
		return displayName.withStyle(
			style -> style.withClickEvent(new ClickEvent.SuggestCommand("/tell " + string + " ")).withHoverEvent(this.createHoverEvent()).withInsertion(string)
		);
	}

	@Override
	public String getScoreboardName() {
		return this.getGameProfile().getName();
	}

	@Override
	protected void internalSetAbsorptionAmount(float absorptionAmount) {
		this.getEntityData().set(DATA_PLAYER_ABSORPTION_ID, absorptionAmount);
	}

	@Override
	public float getAbsorptionAmount() {
		return this.getEntityData().get(DATA_PLAYER_ABSORPTION_ID);
	}

	public boolean isModelPartShown(PlayerModelPart part) {
		return (this.getEntityData().get(DATA_PLAYER_MODE_CUSTOMISATION) & part.getMask()) == part.getMask();
	}

	@Override
	public SlotAccess getSlot(int slot) {
		if (slot == 499) {
			return new SlotAccess() {
				@Override
				public ItemStack get() {
					return Player.this.containerMenu.getCarried();
				}

				@Override
				public boolean set(ItemStack carried) {
					Player.this.containerMenu.setCarried(carried);
					return true;
				}
			};
		} else {
			final int i = slot - 500;
			if (i >= 0 && i < 4) {
				return new SlotAccess() {
					@Override
					public ItemStack get() {
						return Player.this.inventoryMenu.getCraftSlots().getItem(i);
					}

					@Override
					public boolean set(ItemStack carried) {
						Player.this.inventoryMenu.getCraftSlots().setItem(i, carried);
						Player.this.inventoryMenu.slotsChanged(Player.this.inventory);
						return true;
					}
				};
			} else if (slot >= 0 && slot < this.inventory.getNonEquipmentItems().size()) {
				return SlotAccess.forContainer(this.inventory, slot);
			} else {
				int j = slot - 200;
				return j >= 0 && j < this.enderChestInventory.getContainerSize() ? SlotAccess.forContainer(this.enderChestInventory, j) : super.getSlot(slot);
			}
		}
	}

	/**
	 * Whether the "reducedDebugInfo" option is active for this player.
	 */
	public boolean isReducedDebugInfo() {
		return this.reducedDebugInfo;
	}

	public void setReducedDebugInfo(boolean reducedDebugInfo) {
		this.reducedDebugInfo = reducedDebugInfo;
	}

	@Override
	public void setRemainingFireTicks(int remainingFireTicks) {
		super.setRemainingFireTicks(this.abilities.invulnerable ? Math.min(remainingFireTicks, 1) : remainingFireTicks);
	}

	@Override
	public HumanoidArm getMainArm() {
		return this.entityData.get(DATA_PLAYER_MAIN_HAND) == 0 ? HumanoidArm.LEFT : HumanoidArm.RIGHT;
	}

	public void setMainArm(HumanoidArm hand) {
		this.entityData.set(DATA_PLAYER_MAIN_HAND, (byte)(hand == HumanoidArm.LEFT ? 0 : 1));
	}

	public CompoundTag getShoulderEntityLeft() {
		return this.entityData.get(DATA_SHOULDER_LEFT);
	}

	protected void setShoulderEntityLeft(CompoundTag entityCompound) {
		this.entityData.set(DATA_SHOULDER_LEFT, entityCompound);
	}

	public CompoundTag getShoulderEntityRight() {
		return this.entityData.get(DATA_SHOULDER_RIGHT);
	}

	protected void setShoulderEntityRight(CompoundTag entityCompound) {
		this.entityData.set(DATA_SHOULDER_RIGHT, entityCompound);
	}

	public float getCurrentItemAttackStrengthDelay() {
		return (float)(1.0 / this.getAttributeValue(Attributes.ATTACK_SPEED) * 20.0);
	}

	/**
	 * Returns the percentage of attack power available based on the cooldown (zero to one).
	 */
	public float getAttackStrengthScale(float adjustTicks) {
		return Mth.clamp((this.attackStrengthTicker + adjustTicks) / this.getCurrentItemAttackStrengthDelay(), 0.0F, 1.0F);
	}

	public void resetAttackStrengthTicker() {
		this.attackStrengthTicker = 0;
	}

	public ItemCooldowns getCooldowns() {
		return this.cooldowns;
	}

	@Override
	protected float getBlockSpeedFactor() {
		return !this.abilities.flying && !this.isFallFlying() ? super.getBlockSpeedFactor() : 1.0F;
	}

	@Override
	public float getLuck() {
		return (float)this.getAttributeValue(Attributes.LUCK);
	}

	public boolean canUseGameMasterBlocks() {
		return this.abilities.instabuild && this.getPermissionLevel() >= 2;
	}

	public int getPermissionLevel() {
		return 0;
	}

	public boolean hasPermissions(int permissionLevel) {
		return this.getPermissionLevel() >= permissionLevel;
	}

	@Override
	public EntityDimensions getDefaultDimensions(Pose pose) {
		return (EntityDimensions)POSES.getOrDefault(pose, STANDING_DIMENSIONS);
	}

	@Override
	public ImmutableList<Pose> getDismountPoses() {
		return ImmutableList.of(Pose.STANDING, Pose.CROUCHING, Pose.SWIMMING);
	}

	@Override
	public ItemStack getProjectile(ItemStack weaponStack) {
		if (!(weaponStack.getItem() instanceof ProjectileWeaponItem)) {
			return ItemStack.EMPTY;
		} else {
			Predicate<ItemStack> predicate = ((ProjectileWeaponItem)weaponStack.getItem()).getSupportedHeldProjectiles();
			ItemStack itemStack = ProjectileWeaponItem.getHeldProjectile(this, predicate);
			if (!itemStack.isEmpty()) {
				return itemStack;
			} else {
				predicate = ((ProjectileWeaponItem)weaponStack.getItem()).getAllSupportedProjectiles();

				for (int i = 0; i < this.inventory.getContainerSize(); i++) {
					ItemStack itemStack2 = this.inventory.getItem(i);
					if (predicate.test(itemStack2)) {
						return itemStack2;
					}
				}

				return this.hasInfiniteMaterials() ? new ItemStack(Items.ARROW) : ItemStack.EMPTY;
			}
		}
	}

	@Override
	public Vec3 getRopeHoldPosition(float partialTicks) {
		double d = 0.22 * (this.getMainArm() == HumanoidArm.RIGHT ? -1.0 : 1.0);
		float f = Mth.lerp(partialTicks * 0.5F, this.getXRot(), this.xRotO) * (float) (Math.PI / 180.0);
		float g = Mth.lerp(partialTicks, this.yBodyRotO, this.yBodyRot) * (float) (Math.PI / 180.0);
		if (this.isFallFlying() || this.isAutoSpinAttack()) {
			Vec3 vec3 = this.getViewVector(partialTicks);
			Vec3 vec32 = this.getDeltaMovement();
			double e = vec32.horizontalDistanceSqr();
			double h = vec3.horizontalDistanceSqr();
			float k;
			if (e > 0.0 && h > 0.0) {
				double i = (vec32.x * vec3.x + vec32.z * vec3.z) / Math.sqrt(e * h);
				double j = vec32.x * vec3.z - vec32.z * vec3.x;
				k = (float)(Math.signum(j) * Math.acos(i));
			} else {
				k = 0.0F;
			}

			return this.getPosition(partialTicks).add(new Vec3(d, -0.11, 0.85).zRot(-k).xRot(-f).yRot(-g));
		} else if (this.isVisuallySwimming()) {
			return this.getPosition(partialTicks).add(new Vec3(d, 0.2, -0.15).xRot(-f).yRot(-g));
		} else {
			double l = this.getBoundingBox().getYsize() - 1.0;
			double e = this.isCrouching() ? -0.2 : 0.07;
			return this.getPosition(partialTicks).add(new Vec3(d, l, e).yRot(-g));
		}
	}

	@Override
	public boolean isAlwaysTicking() {
		return true;
	}

	public boolean isScoping() {
		return this.isUsingItem() && this.getUseItem().is(Items.SPYGLASS);
	}

	@Override
	public boolean shouldBeSaved() {
		return false;
	}

	public Optional<GlobalPos> getLastDeathLocation() {
		return this.lastDeathLocation;
	}

	public void setLastDeathLocation(Optional<GlobalPos> lastDeathLocation) {
		this.lastDeathLocation = lastDeathLocation;
	}

	@Override
	public float getHurtDir() {
		return this.hurtDir;
	}

	@Override
	public void animateHurt(float yaw) {
		super.animateHurt(yaw);
		this.hurtDir = yaw;
	}

	@Override
	public boolean canSprint() {
		return true;
	}

	@Override
	protected float getFlyingSpeed() {
		if (this.abilities.flying && !this.isPassenger()) {
			return this.isSprinting() ? this.abilities.getFlyingSpeed() * 2.0F : this.abilities.getFlyingSpeed();
		} else {
			return this.isSprinting() ? 0.025999999F : 0.02F;
		}
	}

	public boolean hasClientLoaded() {
		return this.clientLoaded || this.clientLoadedTimeoutTimer <= 0;
	}

	public void tickClientLoadTimeout() {
		if (!this.clientLoaded) {
			this.clientLoadedTimeoutTimer--;
		}
	}

	public void setClientLoaded(boolean clientLoaded) {
		this.clientLoaded = clientLoaded;
		if (!this.clientLoaded) {
			this.clientLoadedTimeoutTimer = 60;
		}
	}

	public double blockInteractionRange() {
		return this.getAttributeValue(Attributes.BLOCK_INTERACTION_RANGE);
	}

	public double entityInteractionRange() {
		return this.getAttributeValue(Attributes.ENTITY_INTERACTION_RANGE);
	}

	public boolean canInteractWithEntity(Entity entity, double distance) {
		return entity.isRemoved() ? false : this.canInteractWithEntity(entity.getBoundingBox(), distance);
	}

	public boolean canInteractWithEntity(AABB boundingBox, double distance) {
		double d = this.entityInteractionRange() + distance;
		return boundingBox.distanceToSqr(this.getEyePosition()) < d * d;
	}

	public boolean canInteractWithBlock(BlockPos pos, double distance) {
		double d = this.blockInteractionRange() + distance;
		return new AABB(pos).distanceToSqr(this.getEyePosition()) < d * d;
	}

	public void setIgnoreFallDamageFromCurrentImpulse(boolean ignoreFallDamageFromCurrentImpulse) {
		this.ignoreFallDamageFromCurrentImpulse = ignoreFallDamageFromCurrentImpulse;
		if (ignoreFallDamageFromCurrentImpulse) {
			this.currentImpulseContextResetGraceTime = 40;
		} else {
			this.currentImpulseContextResetGraceTime = 0;
		}
	}

	public boolean isIgnoringFallDamageFromCurrentImpulse() {
		return this.ignoreFallDamageFromCurrentImpulse;
	}

	public void tryResetCurrentImpulseContext() {
		if (this.currentImpulseContextResetGraceTime == 0) {
			this.resetCurrentImpulseContext();
		}
	}

	public void resetCurrentImpulseContext() {
		this.currentImpulseContextResetGraceTime = 0;
		this.currentExplosionCause = null;
		this.currentImpulseImpactPos = null;
		this.ignoreFallDamageFromCurrentImpulse = false;
	}

	public boolean shouldRotateWithMinecart() {
		return false;
	}

	@Override
	public boolean onClimbable() {
		return this.abilities.flying ? false : super.onClimbable();
	}

	public String debugInfo() {
		return MoreObjects.toStringHelper(this)
			.add("name", this.getName().getString())
			.add("id", this.getId())
			.add("pos", this.position())
			.add("mode", this.gameMode())
			.add("permission", this.getPermissionLevel())
			.toString();
	}

	public static enum BedSleepingProblem {
		NOT_POSSIBLE_HERE,
		NOT_POSSIBLE_NOW(Component.translatable("block.minecraft.bed.no_sleep")),
		TOO_FAR_AWAY(Component.translatable("block.minecraft.bed.too_far_away")),
		OBSTRUCTED(Component.translatable("block.minecraft.bed.obstructed")),
		OTHER_PROBLEM,
		NOT_SAFE(Component.translatable("block.minecraft.bed.not_safe"));

		@Nullable
		private final Component message;

		private BedSleepingProblem() {
			this.message = null;
		}

		private BedSleepingProblem(final Component message) {
			this.message = message;
		}

		@Nullable
		public Component getMessage() {
			return this.message;
		}
	}
}