package com.dairymoose.entity;

import com.dairymoose.modernlife.core.CustomBlocks;
import com.dairymoose.modernlife.core.ModernLifeNetwork;
import com.dairymoose.modernlife.network.play.client.ServerboundFuelLevelPacket;
import com.google.common.collect.Lists;
import com.google.common.collect.UnmodifiableIterator;
import java.util.Iterator;
import java.util.List;
import javax.annotation.Nullable;
import net.minecraft.BlockUtil;
import net.minecraft.client.Minecraft;
import net.minecraft.client.player.Input;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.core.NonNullList;
import net.minecraft.core.particles.ParticleTypes;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.nbt.FloatTag;
import net.minecraft.network.chat.Component;
import net.minecraft.network.chat.TextComponent;
import net.minecraft.network.protocol.Packet;
import net.minecraft.network.protocol.game.ClientboundAddEntityPacket;
import net.minecraft.network.syncher.EntityDataAccessor;
import net.minecraft.network.syncher.EntityDataSerializers;
import net.minecraft.network.syncher.SynchedEntityData;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.sounds.SoundEvent;
import net.minecraft.sounds.SoundEvents;
import net.minecraft.sounds.SoundSource;
import net.minecraft.tags.FluidTags;
import net.minecraft.util.Mth;
import net.minecraft.world.Container;
import net.minecraft.world.ContainerHelper;
import net.minecraft.world.Containers;
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.entity.Entity;
import net.minecraft.world.entity.EntityDimensions;
import net.minecraft.world.entity.EntitySelector;
import net.minecraft.world.entity.EntityType;
import net.minecraft.world.entity.LivingEntity;
import net.minecraft.world.entity.MobCategory;
import net.minecraft.world.entity.MoverType;
import net.minecraft.world.entity.Pose;
import net.minecraft.world.entity.SlotAccess;
import net.minecraft.world.entity.animal.Animal;
import net.minecraft.world.entity.animal.WaterAnimal;
import net.minecraft.world.entity.player.Inventory;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.entity.vehicle.DismountHelper;
import net.minecraft.world.inventory.AbstractContainerMenu;
import net.minecraft.world.inventory.ChestMenu;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.Items;
import net.minecraft.world.level.GameRules;
import net.minecraft.world.level.ItemLike;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.WaterlilyBlock;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.gameevent.GameEvent;
import net.minecraft.world.level.material.FluidState;
import net.minecraft.world.phys.AABB;
import net.minecraft.world.phys.Vec3;
import net.minecraft.world.phys.shapes.BooleanOp;
import net.minecraft.world.phys.shapes.Shapes;
import net.minecraft.world.phys.shapes.VoxelShape;

/* loaded from: outputsrg.jar:com/dairymoose/entity/MotorboatEntity.class */
public class MotorboatEntity extends Entity implements Container, MenuProvider {
    public static final EntityType<MotorboatEntity> MOTORBOAT_ENTITY = EntityType.Builder.of(MotorboatEntity::new, MobCategory.MISC).sized(1.375f, 0.5625f).clientTrackingRange(10).build(new ResourceLocation("modernlife", "motorboat").toString());
    private static final EntityDataAccessor<Integer> DATA_ID_HURT = SynchedEntityData.defineId(MotorboatEntity.class, EntityDataSerializers.INT);
    private static final EntityDataAccessor<Integer> DATA_ID_HURTDIR = SynchedEntityData.defineId(MotorboatEntity.class, EntityDataSerializers.INT);
    private static final EntityDataAccessor<Float> DATA_ID_DAMAGE = SynchedEntityData.defineId(MotorboatEntity.class, EntityDataSerializers.FLOAT);
    private static final EntityDataAccessor<Integer> DATA_ID_TYPE = SynchedEntityData.defineId(MotorboatEntity.class, EntityDataSerializers.INT);
    private static final EntityDataAccessor<Boolean> DATA_ID_PADDLE_LEFT = SynchedEntityData.defineId(MotorboatEntity.class, EntityDataSerializers.BOOLEAN);
    private static final EntityDataAccessor<Boolean> DATA_ID_PADDLE_RIGHT = SynchedEntityData.defineId(MotorboatEntity.class, EntityDataSerializers.BOOLEAN);
    private static final EntityDataAccessor<Integer> DATA_ID_BUBBLE_TIME = SynchedEntityData.defineId(MotorboatEntity.class, EntityDataSerializers.INT);
    private static final EntityDataAccessor<Boolean> DATA_ID_ADDED_FREE_GAS = SynchedEntityData.defineId(MotorboatEntity.class, EntityDataSerializers.BOOLEAN);
    private static final EntityDataAccessor<Float> DATA_ID_FUEL_LEVEL = SynchedEntityData.defineId(MotorboatEntity.class, EntityDataSerializers.FLOAT);
    public static final int PADDLE_LEFT = 0;
    public static final int PADDLE_RIGHT = 1;
    private static final int TIME_TO_EJECT = 60;
    private static final double PADDLE_SPEED = 0.39269909262657166d;
    public static final double PADDLE_SOUND_TIME = 0.7853981852531433d;
    public static final int BUBBLE_TIME = 60;
    private final float[] paddlePositions;
    private float invFriction;
    private float outOfControlTicks;
    private float deltaRotation;
    private int lerpSteps;
    private double lerpX;
    private double lerpY;
    private double lerpZ;
    private double lerpYRot;
    private double lerpXRot;
    private boolean inputLeft;
    private boolean inputRight;
    private boolean inputUp;
    private boolean inputDown;
    private double waterLevel;
    private float landFriction;
    public Status status;
    private Status oldStatus;
    private double lastYd;
    private boolean isAboveBubbleColumn;
    private boolean bubbleColumnDirectionIsDown;
    private float bubbleMultiplier;
    private float bubbleAngle;
    private float bubbleAngleO;
    private float curAccel;
    private float maxAccel;
    private float currentFuelLevelClientOnly;
    public int tickCount;
    private boolean backingUp;
    private NonNullList<ItemStack> itemStacks;
    private static final int MINUTES_UNTIL_EMPTY = 20;
    private static final int TICKS_PER_SEC = 20;
    private static final int SECS_PER_MINUTE = 60;
    public static final int FULL_FUEL_LEVEL = 24000;

    /* loaded from: outputsrg.jar:com/dairymoose/entity/MotorboatEntity$Status.class */
    public enum Status {
        IN_WATER,
        UNDER_WATER,
        UNDER_FLOWING_WATER,
        ON_LAND,
        IN_AIR
    }

    public MotorboatEntity(EntityType<? extends MotorboatEntity> p_38290_, Level p_38291_) {
        super(p_38290_, p_38291_);
        this.paddlePositions = new float[2];
        this.maxAccel = 0.1f;
        this.currentFuelLevelClientOnly = -10.0f;
        this.tickCount = 0;
        this.backingUp = false;
        this.itemStacks = NonNullList.withSize(27, ItemStack.EMPTY);
        this.blocksBuilding = true;
    }

    public void onSyncedDataUpdated(EntityDataAccessor<?> p_20059_) {
        if (p_20059_ == DATA_ID_FUEL_LEVEL) {
            this.currentFuelLevelClientOnly = ((Float) this.entityData.get(DATA_ID_FUEL_LEVEL)).floatValue();
        }
    }

    public MotorboatEntity(Level p_38293_, double p_38294_, double p_38295_, double p_38296_) {
        this(MOTORBOAT_ENTITY, p_38293_);
        setPos(p_38294_, p_38295_, p_38296_);
        this.xo = p_38294_;
        this.yo = p_38295_;
        this.zo = p_38296_;
    }

    public float getCurrentFuelLevel() {
        if (this.currentFuelLevelClientOnly <= -10.0f) {
            float fuelLevel = ((Float) this.entityData.get(DATA_ID_FUEL_LEVEL)).floatValue();
            if (fuelLevel < 0.0f) {
                fuelLevel = 1.0f;
            }
            this.currentFuelLevelClientOnly = fuelLevel;
        }
        return this.currentFuelLevelClientOnly;
    }

    public boolean isOutOfFuel() {
        float fuelLevel = getCurrentFuelLevel();
        return fuelLevel <= 0.0f;
    }

    public void setSyncedFuelLevel(float newLevel) {
        if (newLevel < 0.0f) {
            newLevel = 0.0f;
        }
        this.entityData.set(DATA_ID_FUEL_LEVEL, Float.valueOf(newLevel));
        this.currentFuelLevelClientOnly = newLevel;
    }

    public int getContainerSize() {
        return 27;
    }

    public float getCurAccel() {
        return this.curAccel;
    }

    public float getMaxAccel() {
        return this.maxAccel;
    }

    protected float getEyeHeight(Pose p_38327_, EntityDimensions p_38328_) {
        return p_38328_.height;
    }

    protected MovementEmission getMovementEmission() {
        return MovementEmission.NONE;
    }

    protected void defineSynchedData() {
        this.entityData.define(DATA_ID_HURT, 0);
        this.entityData.define(DATA_ID_HURTDIR, 1);
        this.entityData.define(DATA_ID_DAMAGE, Float.valueOf(0.0f));
        this.entityData.define(DATA_ID_PADDLE_LEFT, false);
        this.entityData.define(DATA_ID_PADDLE_RIGHT, false);
        this.entityData.define(DATA_ID_ADDED_FREE_GAS, false);
        this.entityData.define(DATA_ID_BUBBLE_TIME, 0);
        this.entityData.define(DATA_ID_FUEL_LEVEL, Float.valueOf(1.0f));
    }

    public boolean canCollideWith(Entity p_38376_) {
        return canVehicleCollide(this, p_38376_);
    }

    public static boolean canVehicleCollide(Entity p_38324_, Entity p_38325_) {
        return (p_38325_.canBeCollidedWith() || p_38325_.isPushable()) && !p_38324_.isPassengerOfSameVehicle(p_38325_);
    }

    public boolean canBeCollidedWith() {
        return true;
    }

    public boolean isPushable() {
        return true;
    }

    public boolean isBackingUp() {
        return this.backingUp;
    }

    protected Vec3 getRelativePortalPosition(Direction.Axis p_38335_, BlockUtil.FoundRectangle p_38336_) {
        return LivingEntity.resetForwardDirectionOfRelativePortalPosition(super.getRelativePortalPosition(p_38335_, p_38336_));
    }

    public double getPassengersRidingOffset() {
        return -0.1d;
    }

    public boolean hurt(DamageSource p_38319_, float p_38320_) {
        if (isInvulnerableTo(p_38319_)) {
            return false;
        }
        if (!this.level.isClientSide && !isRemoved()) {
            setHurtDir(-getHurtDir());
            setHurtTime(10);
            setDamage(getDamage() + (p_38320_ * 10.0f));
            markHurt();
            gameEvent(GameEvent.ENTITY_DAMAGED, p_38319_.getEntity());
            boolean flag = (p_38319_.getEntity() instanceof Player) && p_38319_.getEntity().getAbilities().instabuild;
            if (flag || getDamage() > 40.0f) {
                if (!flag && this.level.getGameRules().getBoolean(GameRules.RULE_DOENTITYDROPS)) {
                    ItemStack boatToSpawn = new ItemStack(new ItemLike() { // from class: com.dairymoose.entity.MotorboatEntity.1
                        public Item asItem() {
                            return MotorboatEntity.this.getDropItem();
                        }
                    });
                    float fuelLevel = ((Float) this.entityData.get(DATA_ID_FUEL_LEVEL)).floatValue();
                    boatToSpawn.addTagElement("FuelLevel", FloatTag.valueOf(fuelLevel));
                    spawnAtLocation(boatToSpawn);
                }
                discard();
                return true;
            }
            return true;
        }
        return true;
    }

    public void onAboveBubbleCol(boolean p_38381_) {
        if (!this.level.isClientSide) {
            this.isAboveBubbleColumn = true;
            this.bubbleColumnDirectionIsDown = p_38381_;
            if (getBubbleTime() == 0) {
                setBubbleTime(60);
            }
        }
        this.level.addParticle(ParticleTypes.SPLASH, getX() + this.random.nextFloat(), getY() + 0.7d, getZ() + this.random.nextFloat(), 0.0d, 0.0d, 0.0d);
        if (this.random.nextInt(20) == 0) {
            this.level.playLocalSound(getX(), getY(), getZ(), getSwimSplashSound(), getSoundSource(), 1.0f, 0.8f + (0.4f * this.random.nextFloat()), false);
        }
        gameEvent(GameEvent.SPLASH, getControllingPassenger());
    }

    public void push(Entity p_38373_) {
        if (p_38373_ instanceof MotorboatEntity) {
            if (p_38373_.getBoundingBox().minY < getBoundingBox().maxY) {
                super.push(p_38373_);
            }
        } else if (p_38373_.getBoundingBox().minY <= getBoundingBox().minY) {
            super.push(p_38373_);
        }
    }

    public Item getDropItem() {
        return CustomBlocks.ITEM_MOTORBOAT.get();
    }

    public void animateHurt() {
        setHurtDir(-getHurtDir());
        setHurtTime(10);
        setDamage(getDamage() * 11.0f);
    }

    public boolean isPickable() {
        return !isRemoved();
    }

    public void lerpTo(double p_38299_, double p_38300_, double p_38301_, float p_38302_, float p_38303_, int p_38304_, boolean p_38305_) {
        this.lerpX = p_38299_;
        this.lerpY = p_38300_;
        this.lerpZ = p_38301_;
        this.lerpYRot = p_38302_;
        this.lerpXRot = p_38303_;
        this.lerpSteps = 10;
    }

    public Direction getMotionDirection() {
        return getDirection().getClockWise();
    }

    private void motorboatSound(Level world, Player player, int count) {
        if (count % 4 != 0 || this.status != Status.IN_WATER || isOutOfFuel()) {
            return;
        }
        float volumeDiff = 1.0f - 0.7f;
        float currentVolume = 0.7f + ((this.curAccel / this.maxAccel) * volumeDiff);
        float pitchDiff = 1.8f - 1.0f;
        float currentPitch = 1.0f + ((this.curAccel / this.maxAccel) * pitchDiff);
        if (currentVolume < 0.7f) {
            currentVolume = 0.7f;
        }
        if (currentPitch < 1.0f) {
            currentPitch = 1.0f;
        }
        if (player == null) {
            if (isControlledByLocalInstance()) {
                Minecraft.getInstance().player.playSound(CustomBlocks.SOUND_BOAT_MOTOR.get(), currentVolume, currentPitch);
                return;
            }
            return;
        }
        world.playSound(player, player.blockPosition(), CustomBlocks.SOUND_BOAT_MOTOR.get(), SoundSource.BLOCKS, currentVolume, currentPitch);
    }

    public void tick() {
        SoundEvent soundevent;
        this.tickCount++;
        if (this.level.isClientSide && isControlledByLocalInstance()) {
            if (Minecraft.getInstance().player != null) {
                Input pInput = Minecraft.getInstance().player.input;
                setInput(pInput.left, pInput.right, pInput.up, pInput.down);
            }
        } else {
            setInput(false, false, false, false);
        }
        this.oldStatus = this.status;
        this.status = getStatus();
        if (this.status == Status.UNDER_WATER || this.status == Status.UNDER_FLOWING_WATER) {
            this.outOfControlTicks += 1.0f;
        } else {
            this.outOfControlTicks = 0.0f;
        }
        if (!this.level.isClientSide && this.outOfControlTicks >= 60.0f) {
            ejectPassengers();
        }
        if (getHurtTime() > 0) {
            setHurtTime(getHurtTime() - 1);
        }
        if (getDamage() > 0.0f) {
            setDamage(getDamage() - 1.0f);
        }
        super.tick();
        tickLerp();
        Entity controller = getControllingPassenger();
        Player controllingPlayer = null;
        if (controller instanceof Player) {
            controllingPlayer = (Player) controller;
        }
        if (controllingPlayer != null) {
            Vec3 currentPos = new Vec3(getX(), getY(), getZ());
            Vec3 deltaMov = new Vec3(0.8d, 0.0d, 0.0d).yRot(((-(getYRot() - 30.0f)) * 0.017453292f) - 1.5707964f);
            Vec3 deltaMov2 = new Vec3(0.8d, 0.0d, 0.0d).yRot(((-(getYRot() + 30.0f)) * 0.017453292f) - 1.5707964f);
            Vec3 scaled1_left = currentPos.add(deltaMov.scale(1.0d));
            Vec3 scaled1_right = currentPos.add(deltaMov2.scale(1.0d));
            BlockPos posToCheck1_left = new BlockPos(scaled1_left.x, scaled1_left.y, scaled1_left.z).above();
            BlockPos posToCheck1_right = new BlockPos(scaled1_right.x, scaled1_right.y, scaled1_right.z).above();
            BlockState state1 = this.level.getBlockState(posToCheck1_left);
            BlockState state2 = this.level.getBlockState(posToCheck1_right);
            if (state1.is(Blocks.LILY_PAD) || state2.is(Blocks.LILY_PAD)) {
                if ((this.level instanceof ServerLevel) && state1.is(Blocks.LILY_PAD)) {
                    this.level.m_46961_(posToCheck1_left, true);
                }
                if ((this.level instanceof ServerLevel) && state2.is(Blocks.LILY_PAD)) {
                    this.level.m_46961_(posToCheck1_right, true);
                }
            }
            if (this.level.isClientSide) {
                motorboatSound(this.level, null, this.tickCount);
            } else {
                motorboatSound(this.level, controllingPlayer, this.tickCount);
            }
        }
        if (isControlledByLocalInstance()) {
            if (!(getFirstPassenger() instanceof Player)) {
                setPaddleState(false, false);
            }
            floatMotorboatEntity();
            if (this.level.isClientSide) {
                controlMotorboatEntity();
            }
            move(MoverType.SELF, getDeltaMovement());
            if (this.horizontalCollision) {
                this.curAccel = 0.0f;
            }
        } else {
            setDeltaMovement(Vec3.ZERO);
        }
        tickBubbleColumn();
        int i = 0;
        while (i <= 1) {
            if (getPaddleState(i)) {
                if (!isSilent() && this.paddlePositions[i] % 6.2831855f <= 0.7853981852531433d && (this.paddlePositions[i] + PADDLE_SPEED) % 6.2831854820251465d >= 0.7853981852531433d && (soundevent = getPaddleSound()) != null) {
                    Vec3 vec3 = getViewVector(1.0f);
                    double d0 = i == 1 ? -vec3.z : vec3.z;
                    double d1 = i == 1 ? vec3.x : -vec3.x;
                    this.level.playSound((Player) null, getX() + d0, getY(), getZ() + d1, soundevent, getSoundSource(), 1.0f, 0.8f + (0.4f * this.random.nextFloat()));
                    this.level.gameEvent(getControllingPassenger(), GameEvent.SPLASH, new BlockPos(getX() + d0, getY(), getZ() + d1));
                }
                this.paddlePositions[i] = (float) (this.paddlePositions[i] + PADDLE_SPEED);
            } else {
                this.paddlePositions[i] = 0.0f;
            }
            i++;
        }
        checkInsideBlocks();
        List<Entity> list = this.level.getEntities(this, getBoundingBox().inflate(0.20000000298023224d, -0.009999999776482582d, 0.20000000298023224d), EntitySelector.pushableBy(this));
        if (!list.isEmpty()) {
            boolean flag = (this.level.isClientSide || (getControllingPassenger() instanceof Player)) ? false : true;
            for (int j = 0; j < list.size(); j++) {
                Entity entity = list.get(j);
                if (!entity.hasPassenger(this)) {
                    if (flag && getPassengers().size() < 4 && !entity.isPassenger() && entity.getBbWidth() < getBbWidth() && (entity instanceof LivingEntity) && !(entity instanceof WaterAnimal) && !(entity instanceof Player)) {
                        entity.startRiding(this);
                    } else {
                        push(entity);
                    }
                }
            }
        }
    }

    private void tickBubbleColumn() {
        if (this.level.isClientSide) {
            int i = getBubbleTime();
            if (i > 0) {
                this.bubbleMultiplier += 0.05f;
            } else {
                this.bubbleMultiplier -= 0.1f;
            }
            this.bubbleMultiplier = Mth.clamp(this.bubbleMultiplier, 0.0f, 1.0f);
            this.bubbleAngleO = this.bubbleAngle;
            this.bubbleAngle = 10.0f * ((float) Math.sin(0.5f * ((float) this.level.getGameTime()))) * this.bubbleMultiplier;
            return;
        }
        if (!this.isAboveBubbleColumn) {
            setBubbleTime(0);
        }
        int k = getBubbleTime();
        if (k > 0) {
            int k2 = k - 1;
            setBubbleTime(k2);
            int j = (60 - k2) - 1;
            if (j > 0 && k2 == 0) {
                setBubbleTime(0);
                Vec3 vec3 = getDeltaMovement();
                if (this.bubbleColumnDirectionIsDown) {
                    setDeltaMovement(vec3.add(0.0d, -0.7d, 0.0d));
                    ejectPassengers();
                } else {
                    setDeltaMovement(vec3.x, hasPassenger(p_150274_ -> {
                        return p_150274_ instanceof Player;
                    }) ? 2.7d : 0.6d, vec3.z);
                }
            }
            this.isAboveBubbleColumn = false;
        }
    }

    @Nullable
    protected SoundEvent getPaddleSound() {
        switch (getStatus()) {
            case IN_WATER:
            case UNDER_WATER:
            case UNDER_FLOWING_WATER:
                return SoundEvents.BOAT_PADDLE_WATER;
            case ON_LAND:
                return SoundEvents.BOAT_PADDLE_LAND;
            case IN_AIR:
            default:
                return null;
        }
    }

    private void tickLerp() {
        if (isControlledByLocalInstance()) {
            this.lerpSteps = 0;
            setPacketCoordinates(getX(), getY(), getZ());
        }
        if (this.lerpSteps > 0) {
            double d0 = getX() + ((this.lerpX - getX()) / this.lerpSteps);
            double d1 = getY() + ((this.lerpY - getY()) / this.lerpSteps);
            double d2 = getZ() + ((this.lerpZ - getZ()) / this.lerpSteps);
            double d3 = Mth.wrapDegrees(this.lerpYRot - getYRot());
            setYRot(getYRot() + (((float) d3) / this.lerpSteps));
            setXRot(getXRot() + (((float) (this.lerpXRot - getXRot())) / this.lerpSteps));
            this.lerpSteps--;
            setPos(d0, d1, d2);
            setRot(getYRot(), getXRot());
        }
    }

    public void setPaddleState(boolean p_38340_, boolean p_38341_) {
        this.entityData.set(DATA_ID_PADDLE_LEFT, Boolean.valueOf(p_38340_));
        this.entityData.set(DATA_ID_PADDLE_RIGHT, Boolean.valueOf(p_38341_));
    }

    public float getRowingTime(int p_38316_, float p_38317_) {
        if (getPaddleState(p_38316_)) {
            return (float) Mth.clampedLerp(this.paddlePositions[p_38316_] - PADDLE_SPEED, this.paddlePositions[p_38316_], p_38317_);
        }
        return 0.0f;
    }

    public Status getStatus() {
        Status boat$status = isUnderwater();
        if (boat$status != null) {
            this.waterLevel = getBoundingBox().maxY;
            return boat$status;
        }
        if (checkInWater()) {
            return Status.IN_WATER;
        }
        float f = getGroundFriction();
        if (f > 0.0f) {
            this.landFriction = f;
            return Status.ON_LAND;
        }
        return Status.IN_AIR;
    }

    /* JADX WARN: Code restructure failed: missing block: B:17:0x00c4, code lost:
    
        r14 = r14 + 1;
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct code enable 'Show inconsistent code' option in preferences
    */
    public float getWaterLevelAbove() {
        /*
            r5 = this;
            r0 = r5
            net.minecraft.world.phys.AABB r0 = r0.getBoundingBox()
            r6 = r0
            r0 = r6
            double r0 = r0.minX
            int r0 = net.minecraft.util.Mth.floor(r0)
            r7 = r0
            r0 = r6
            double r0 = r0.maxX
            int r0 = net.minecraft.util.Mth.ceil(r0)
            r8 = r0
            r0 = r6
            double r0 = r0.maxY
            int r0 = net.minecraft.util.Mth.floor(r0)
            r9 = r0
            r0 = r6
            double r0 = r0.maxY
            r1 = r5
            double r1 = r1.lastYd
            double r0 = r0 - r1
            int r0 = net.minecraft.util.Mth.ceil(r0)
            r10 = r0
            r0 = r6
            double r0 = r0.minZ
            int r0 = net.minecraft.util.Mth.floor(r0)
            r11 = r0
            r0 = r6
            double r0 = r0.maxZ
            int r0 = net.minecraft.util.Mth.ceil(r0)
            r12 = r0
            net.minecraft.core.BlockPos$MutableBlockPos r0 = new net.minecraft.core.BlockPos$MutableBlockPos
            r1 = r0
            r1.<init>()
            r13 = r0
            r0 = r9
            r14 = r0
        L4b:
            r0 = r14
            r1 = r10
            if (r0 >= r1) goto Lca
            r0 = 0
            r15 = r0
            r0 = r7
            r16 = r0
        L58:
            r0 = r16
            r1 = r8
            if (r0 >= r1) goto Lb3
            r0 = r11
            r17 = r0
        L62:
            r0 = r17
            r1 = r12
            if (r0 >= r1) goto Lad
            r0 = r13
            r1 = r16
            r2 = r14
            r3 = r17
            net.minecraft.core.BlockPos$MutableBlockPos r0 = r0.set(r1, r2, r3)
            r0 = r5
            net.minecraft.world.level.Level r0 = r0.level
            r1 = r13
            net.minecraft.world.level.material.FluidState r0 = r0.getFluidState(r1)
            r18 = r0
            r0 = r18
            net.minecraft.tags.TagKey r1 = net.minecraft.tags.FluidTags.WATER
            boolean r0 = r0.is(r1)
            if (r0 == 0) goto L9d
            r0 = r15
            r1 = r18
            r2 = r5
            net.minecraft.world.level.Level r2 = r2.level
            r3 = r13
            float r1 = r1.getHeight(r2, r3)
            float r0 = java.lang.Math.max(r0, r1)
            r15 = r0
        L9d:
            r0 = r15
            r1 = 1065353216(0x3f800000, float:1.0)
            int r0 = (r0 > r1 ? 1 : (r0 == r1 ? 0 : -1))
            if (r0 < 0) goto La7
            goto Lc4
        La7:
            int r17 = r17 + 1
            goto L62
        Lad:
            int r16 = r16 + 1
            goto L58
        Lb3:
            r0 = r15
            r1 = 1065353216(0x3f800000, float:1.0)
            int r0 = (r0 > r1 ? 1 : (r0 == r1 ? 0 : -1))
            if (r0 >= 0) goto Lc4
            r0 = r13
            int r0 = r0.getY()
            float r0 = (float) r0
            r1 = r15
            float r0 = r0 + r1
            return r0
        Lc4:
            int r14 = r14 + 1
            goto L4b
        Lca:
            r0 = r10
            r1 = 1
            int r0 = r0 + r1
            float r0 = (float) r0
            return r0
        */
        throw new UnsupportedOperationException("Method not decompiled: com.dairymoose.entity.MotorboatEntity.getWaterLevelAbove():float");
    }

    public float getGroundFriction() {
        AABB aabb = getBoundingBox();
        AABB aabb1 = new AABB(aabb.minX, aabb.minY - 0.001d, aabb.minZ, aabb.maxX, aabb.minY, aabb.maxZ);
        int i = Mth.floor(aabb1.minX) - 1;
        int j = Mth.ceil(aabb1.maxX) + 1;
        int k = Mth.floor(aabb1.minY) - 1;
        int l = Mth.ceil(aabb1.maxY) + 1;
        int i1 = Mth.floor(aabb1.minZ) - 1;
        int j1 = Mth.ceil(aabb1.maxZ) + 1;
        VoxelShape voxelshape = Shapes.create(aabb1);
        float f = 0.0f;
        int k1 = 0;
        BlockPos.MutableBlockPos blockpos$mutableblockpos = new BlockPos.MutableBlockPos();
        int l1 = i;
        while (l1 < j) {
            int i2 = i1;
            while (i2 < j1) {
                int j2 = ((l1 == i || l1 == j - 1) ? 1 : 0) + ((i2 == i1 || i2 == j1 - 1) ? 1 : 0);
                if (j2 != 2) {
                    for (int k2 = k; k2 < l; k2++) {
                        if (j2 <= 0 || (k2 != k && k2 != l - 1)) {
                            blockpos$mutableblockpos.set(l1, k2, i2);
                            BlockState blockstate = this.level.getBlockState(blockpos$mutableblockpos);
                            if (!(blockstate.getBlock() instanceof WaterlilyBlock) && Shapes.joinIsNotEmpty(blockstate.m_60812_(this.level, blockpos$mutableblockpos).move(l1, k2, i2), voxelshape, BooleanOp.AND)) {
                                f += blockstate.getFriction(this.level, blockpos$mutableblockpos, this);
                                k1++;
                            }
                        }
                    }
                }
                i2++;
            }
            l1++;
        }
        return f / k1;
    }

    private boolean checkInWater() {
        AABB aabb = getBoundingBox();
        int i = Mth.floor(aabb.minX);
        int j = Mth.ceil(aabb.maxX);
        int k = Mth.floor(aabb.minY);
        int l = Mth.ceil(aabb.minY + 0.001d);
        int i1 = Mth.floor(aabb.minZ);
        int j1 = Mth.ceil(aabb.maxZ);
        boolean flag = false;
        this.waterLevel = -1.7976931348623157E308d;
        BlockPos.MutableBlockPos blockpos$mutableblockpos = new BlockPos.MutableBlockPos();
        for (int k1 = i; k1 < j; k1++) {
            for (int l1 = k; l1 < l; l1++) {
                for (int i2 = i1; i2 < j1; i2++) {
                    blockpos$mutableblockpos.set(k1, l1, i2);
                    FluidState fluidstate = this.level.getFluidState(blockpos$mutableblockpos);
                    if (fluidstate.is(FluidTags.WATER)) {
                        float f = l1 + fluidstate.getHeight(this.level, blockpos$mutableblockpos);
                        this.waterLevel = Math.max(f, this.waterLevel);
                        flag |= aabb.minY < ((double) f);
                    }
                }
            }
        }
        return flag;
    }

    @Nullable
    private Status isUnderwater() {
        AABB aabb = getBoundingBox();
        double d0 = aabb.maxY + 0.001d;
        int i = Mth.floor(aabb.minX);
        int j = Mth.ceil(aabb.maxX);
        int k = Mth.floor(aabb.maxY);
        int l = Mth.ceil(d0);
        int i1 = Mth.floor(aabb.minZ);
        int j1 = Mth.ceil(aabb.maxZ);
        boolean flag = false;
        BlockPos.MutableBlockPos blockpos$mutableblockpos = new BlockPos.MutableBlockPos();
        for (int k1 = i; k1 < j; k1++) {
            for (int l1 = k; l1 < l; l1++) {
                for (int i2 = i1; i2 < j1; i2++) {
                    blockpos$mutableblockpos.set(k1, l1, i2);
                    FluidState fluidstate = this.level.getFluidState(blockpos$mutableblockpos);
                    if (fluidstate.is(FluidTags.WATER) && d0 < blockpos$mutableblockpos.getY() + fluidstate.getHeight(this.level, blockpos$mutableblockpos)) {
                        if (!fluidstate.isSource()) {
                            return Status.UNDER_FLOWING_WATER;
                        }
                        flag = true;
                    }
                }
            }
        }
        if (flag) {
            return Status.UNDER_WATER;
        }
        return null;
    }

    private void floatMotorboatEntity() {
        double d1 = isNoGravity() ? 0.0d : -0.03999999910593033d;
        double d2 = 0.0d;
        this.invFriction = 0.05f;
        if (this.oldStatus == Status.IN_AIR && this.status != Status.IN_AIR && this.status != Status.ON_LAND) {
            this.curAccel = 0.0f;
            this.waterLevel = getY(1.0d);
            setPos(getX(), (getWaterLevelAbove() - getBbHeight()) + 0.101d, getZ());
            setDeltaMovement(getDeltaMovement().multiply(1.0d, 0.0d, 1.0d));
            this.lastYd = 0.0d;
            this.status = Status.IN_WATER;
            return;
        }
        if (this.status == Status.IN_WATER) {
            d2 = (this.waterLevel - getY()) / getBbHeight();
            this.invFriction = 0.9f;
        } else if (this.status == Status.UNDER_FLOWING_WATER) {
            d1 = -7.0E-4d;
            this.invFriction = 0.9f;
        } else if (this.status == Status.UNDER_WATER) {
            d2 = 0.009999999776482582d;
            this.invFriction = 0.45f;
        } else if (this.status == Status.IN_AIR) {
            this.invFriction = 0.9f;
        } else if (this.status == Status.ON_LAND) {
            this.invFriction = this.landFriction;
            if (getControllingPassenger() instanceof Player) {
                this.landFriction /= 2.0f;
            }
        }
        Vec3 vec3 = getDeltaMovement();
        setDeltaMovement(vec3.x * this.invFriction, vec3.y + d1, vec3.z * this.invFriction);
        this.deltaRotation *= this.invFriction;
        if (d2 > 0.0d) {
            Vec3 vec31 = getDeltaMovement();
            setDeltaMovement(vec31.x, (vec31.y + (d2 * 0.06153846016296973d)) * 0.75d, vec31.z);
        }
    }

    private void controlMotorboatEntity() {
        if (isVehicle()) {
            float accel = 0.0f;
            if (this.inputLeft) {
                this.deltaRotation -= 1.0f;
            }
            if (this.inputRight) {
                this.deltaRotation += 1.0f;
            }
            if (this.status == Status.ON_LAND) {
                this.curAccel = 0.0f;
                if (this.inputRight != this.inputLeft && !this.inputUp && !this.inputDown) {
                    this.curAccel = 0.005f;
                }
                setYRot(getYRot() + this.deltaRotation);
                if (this.inputUp) {
                    this.curAccel = 0.04f;
                }
                this.backingUp = false;
                if (this.inputDown) {
                    this.curAccel = -0.04f;
                }
            } else {
                if (this.inputRight != this.inputLeft && !this.inputUp && !this.inputDown) {
                    accel = 0.0f + (0.005f / 70.0f);
                }
                setYRot(getYRot() + this.deltaRotation);
                if (this.inputUp) {
                    if (this.curAccel != 0.0f) {
                        accel += 0.04f / 70.0f;
                    } else {
                        accel += 0.03f;
                    }
                }
                this.backingUp = false;
                if (this.inputDown) {
                    if (this.curAccel > 0.0f) {
                        accel -= 0.15f / 70.0f;
                    } else {
                        this.backingUp = true;
                        accel -= 0.04f / 70.0f;
                    }
                }
                if (!this.inputUp && !this.inputDown) {
                    if (this.curAccel > 0.0f) {
                        this.curAccel -= 0.015f / 70.0f;
                    } else if (this.curAccel < 0.0f) {
                        this.curAccel += 0.015f / 70.0f;
                    }
                    if (this.curAccel > 0.0f && this.curAccel <= 0.015f) {
                        this.curAccel = 0.0f;
                    }
                    if (this.curAccel < 0.0f && this.curAccel >= (-0.015f)) {
                        this.curAccel = 0.0f;
                    }
                }
                this.curAccel += accel;
                if (this.curAccel > this.maxAccel) {
                    this.curAccel = this.maxAccel;
                }
                float maxNegativeAccel = (-this.maxAccel) / 3.0f;
                if (this.curAccel < maxNegativeAccel) {
                    this.curAccel = maxNegativeAccel;
                }
                if (isOutOfFuel()) {
                    this.curAccel = Math.min(this.curAccel, 0.005f);
                    this.curAccel = Math.max(this.curAccel, -0.005f);
                }
                float newFuelLevel = this.currentFuelLevelClientOnly - (Math.abs(this.curAccel) * 4.1666665E-4f);
                if (newFuelLevel < 0.0f) {
                    newFuelLevel = 0.0f;
                }
                this.currentFuelLevelClientOnly = newFuelLevel;
                if (this.tickCount % 100 == 0) {
                    setSyncedFuelLevel(this.currentFuelLevelClientOnly);
                    ModernLifeNetwork.INSTANCE.sendToServer(new ServerboundFuelLevelPacket(this.currentFuelLevelClientOnly, getId()));
                }
            }
            setDeltaMovement(getDeltaMovement().add(Mth.sin((-getYRot()) * 0.017453292f) * this.curAccel, 0.0d, Mth.cos(getYRot() * 0.017453292f) * this.curAccel));
            setPaddleState((this.inputRight && !this.inputLeft) || this.inputUp, (this.inputLeft && !this.inputRight) || this.inputUp);
        }
    }

    public void positionRider(Entity entity) {
        if (hasPassenger(entity)) {
            float f = 0.0f;
            float f1 = (float) ((isRemoved() ? 0.009999999776482582d : getPassengersRidingOffset()) + entity.getMyRidingOffset());
            if (getPassengers().size() > 0) {
                getPassengers().indexOf(entity);
                f = 0.5f;
            }
            int i = getPassengers().indexOf(entity);
            float[] passengerAngles = {-47.5f, 47.5f, 227.5f, 132.5f};
            Vec3 vec3 = new Vec3(f, 0.0d, 0.0d).yRot(((-(getYRot() + passengerAngles[i % 4])) * 0.017453292f) - 1.5707964f);
            entity.setPos(getX() + vec3.x, getY() + f1, getZ() + vec3.z);
            entity.setYRot(entity.getYRot() + this.deltaRotation);
            entity.setYHeadRot(entity.getYHeadRot() + this.deltaRotation);
            clampRotation(entity);
            if ((entity instanceof Animal) && getPassengers().size() > 1) {
                int j = entity.getId() % 2 == 0 ? 90 : 270;
                entity.setYBodyRot(((Animal) entity).f_20883_ + j);
                entity.setYHeadRot(entity.getYHeadRot() + j);
            }
        }
    }

    protected void removePassenger(Entity entity) {
        if (this.level.isClientSide) {
            if (entity.hasCustomName()) {
                entity.setCustomNameVisible(true);
            }
            if (this.level.isClientSide && getControllingPassenger().getId() == entity.getId() && isControlledByLocalInstance()) {
                setSyncedFuelLevel(this.currentFuelLevelClientOnly);
                ModernLifeNetwork.INSTANCE.sendToServer(new ServerboundFuelLevelPacket(this.currentFuelLevelClientOnly, getId()));
            }
        }
        super.removePassenger(entity);
    }

    public Vec3 getDismountLocationForPassenger(LivingEntity entity) {
        Vec3 vec3 = Entity.getCollisionHorizontalEscapeVector(getBbWidth() * Mth.SQRT_OF_TWO, entity.getBbWidth(), entity.getYRot());
        double d0 = getX() + vec3.x;
        double d1 = getZ() + vec3.z;
        BlockPos blockpos = new BlockPos(d0, getBoundingBox().maxY, d1);
        BlockPos blockpos1 = blockpos.below();
        if (!this.level.isWaterAt(blockpos1)) {
            List<Vec3> list = Lists.newArrayList();
            double d2 = this.level.getBlockFloorHeight(blockpos);
            if (DismountHelper.isBlockFloorValid(d2)) {
                list.add(new Vec3(d0, blockpos.getY() + d2, d1));
            }
            double d3 = this.level.getBlockFloorHeight(blockpos1);
            if (DismountHelper.isBlockFloorValid(d3)) {
                list.add(new Vec3(d0, blockpos1.getY() + d3, d1));
            }
            UnmodifiableIterator it = entity.getDismountPoses().iterator();
            while (it.hasNext()) {
                Pose pose = (Pose) it.next();
                for (Vec3 vec31 : list) {
                    if (DismountHelper.canDismountTo(this.level, vec31, entity, pose)) {
                        entity.setPose(pose);
                        return vec31;
                    }
                }
            }
        }
        return super.getDismountLocationForPassenger(entity);
    }

    protected void clampRotation(Entity p_38322_) {
        p_38322_.setYBodyRot(getYRot());
        float f = Mth.wrapDegrees(p_38322_.getYRot() - getYRot());
        float f1 = Mth.clamp(f, -105.0f, 105.0f);
        p_38322_.yRotO += f1 - f;
        p_38322_.setYRot((p_38322_.getYRot() + f1) - f);
        p_38322_.setYHeadRot(p_38322_.getYRot());
    }

    public void onPassengerTurned(Entity p_38383_) {
        clampRotation(p_38383_);
    }

    public InteractionResult interact(Player player, InteractionHand p_38331_) {
        if (player.isSecondaryUseActive()) {
            if (!this.level.isClientSide) {
                return InteractionResult.CONSUME;
            }
            return InteractionResult.SUCCESS;
        }
        if (this.outOfControlTicks < 60.0f) {
            if (!this.level.isClientSide) {
                ItemStack mainItem = player.getMainHandItem();
                if (!mainItem.is(CustomBlocks.ITEM_GAS_CAN.get())) {
                    return player.startRiding(this) ? InteractionResult.CONSUME : InteractionResult.PASS;
                }
                float fuelLevel = ((Float) this.entityData.get(DATA_ID_FUEL_LEVEL)).floatValue();
                int fuelAsInteger = (int) (fuelLevel * 24000.0f);
                int deficit = FULL_FUEL_LEVEL - fuelAsInteger;
                int remainingDurability = mainItem.getMaxDamage() - mainItem.getDamageValue();
                int durabilityToConsume = Math.min(deficit, remainingDurability);
                if (durabilityToConsume > 0) {
                    mainItem.hurtAndBreak(durabilityToConsume, player, p -> {
                    });
                    this.level.playSound((Player) null, player.blockPosition(), SoundEvents.BUCKET_FILL, SoundSource.BLOCKS, 1.0f, 1.0f);
                    float fuelAsFloat = (fuelAsInteger + durabilityToConsume) / 24000.0f;
                    setSyncedFuelLevel(fuelAsFloat);
                }
                return InteractionResult.CONSUME;
            }
            return InteractionResult.SUCCESS;
        }
        return InteractionResult.PASS;
    }

    protected void checkFallDamage(double p_38307_, boolean p_38308_, BlockState p_38309_, BlockPos p_38310_) {
        this.lastYd = getDeltaMovement().y;
        if (!isPassenger()) {
            if (p_38308_) {
                if (this.fallDistance > 3.0f) {
                    if (this.status != Status.ON_LAND) {
                        resetFallDistance();
                        return;
                    }
                    causeFallDamage(this.fallDistance, 1.0f, DamageSource.FALL);
                    if (!this.level.isClientSide && !isRemoved()) {
                        kill();
                        if (this.level.getGameRules().getBoolean(GameRules.RULE_DOENTITYDROPS)) {
                            for (int i = 0; i < 3; i++) {
                                spawnAtLocation(new ItemLike() { // from class: com.dairymoose.entity.MotorboatEntity.2
                                    public Item asItem() {
                                        return Items.IRON_BLOCK;
                                    }
                                });
                            }
                            for (int j = 0; j < 2; j++) {
                                spawnAtLocation(Items.STICK);
                            }
                        }
                    }
                }
                resetFallDistance();
                return;
            }
            if (!this.level.getFluidState(blockPosition().below()).is(FluidTags.WATER) && p_38307_ < 0.0d) {
                this.fallDistance = (float) (this.fallDistance - p_38307_);
            }
        }
    }

    public boolean getPaddleState(int p_38314_) {
        return ((Boolean) this.entityData.get(p_38314_ == 0 ? DATA_ID_PADDLE_LEFT : DATA_ID_PADDLE_RIGHT)).booleanValue() && getControllingPassenger() != null;
    }

    public void setDamage(float p_38312_) {
        this.entityData.set(DATA_ID_DAMAGE, Float.valueOf(p_38312_));
    }

    public float getDamage() {
        return ((Float) this.entityData.get(DATA_ID_DAMAGE)).floatValue();
    }

    public void setHurtTime(int p_38355_) {
        this.entityData.set(DATA_ID_HURT, Integer.valueOf(p_38355_));
    }

    public int getHurtTime() {
        return ((Integer) this.entityData.get(DATA_ID_HURT)).intValue();
    }

    private void setBubbleTime(int p_38367_) {
        this.entityData.set(DATA_ID_BUBBLE_TIME, Integer.valueOf(p_38367_));
    }

    private int getBubbleTime() {
        return ((Integer) this.entityData.get(DATA_ID_BUBBLE_TIME)).intValue();
    }

    public float getBubbleAngle(float p_38353_) {
        return Mth.lerp(p_38353_, this.bubbleAngleO, this.bubbleAngle);
    }

    public void setHurtDir(int p_38363_) {
        this.entityData.set(DATA_ID_HURTDIR, Integer.valueOf(p_38363_));
    }

    public int getHurtDir() {
        return ((Integer) this.entityData.get(DATA_ID_HURTDIR)).intValue();
    }

    protected boolean canAddPassenger(Entity p_38390_) {
        return getPassengers().size() < 4 && !isEyeInFluid(FluidTags.WATER);
    }

    @Nullable
    public Entity getControllingPassenger() {
        return getFirstPassenger();
    }

    public void setInput(boolean p_38343_, boolean p_38344_, boolean p_38345_, boolean p_38346_) {
        this.inputLeft = p_38343_;
        this.inputRight = p_38344_;
        this.inputUp = p_38345_;
        this.inputDown = p_38346_;
    }

    public Packet<?> getAddEntityPacket() {
        return new ClientboundAddEntityPacket(this);
    }

    public boolean isUnderWater() {
        return this.status == Status.UNDER_WATER || this.status == Status.UNDER_FLOWING_WATER;
    }

    protected void addPassenger(Entity passenger) {
        if (passenger.hasCustomName()) {
            passenger.setCustomNameVisible(false);
        }
        super.addPassenger(passenger);
        if (hasExactlyOnePlayerPassenger()) {
            if (this.level.isClientSide) {
                this.currentFuelLevelClientOnly = ((Float) this.entityData.get(DATA_ID_FUEL_LEVEL)).floatValue();
            }
            this.curAccel = 0.0f;
        }
        if (isControlledByLocalInstance() && this.lerpSteps > 0) {
            this.lerpSteps = 0;
            absMoveTo(this.lerpX, this.lerpY, this.lerpZ, (float) this.lerpYRot, (float) this.lerpXRot);
        }
    }

    public ItemStack getPickResult() {
        return new ItemStack(getDropItem());
    }

    public void m_6211_() {
        this.itemStacks.clear();
    }

    /* renamed from: createMenu */
    public AbstractContainerMenu createMenu(int var1, Inventory var2, Player var3) {
        if (var3.isSpectator()) {
            return null;
        }
        return ChestMenu.threeRows(var1, var2, this);
    }

    public Component getDisplayName() {
        return new TextComponent("Motorboat");
    }

    public boolean isEmpty() {
        Iterator it = this.itemStacks.iterator();
        while (it.hasNext()) {
            ItemStack itemstack = (ItemStack) it.next();
            if (!itemstack.isEmpty()) {
                return false;
            }
        }
        return true;
    }

    public ItemStack getItem(int p_38218_) {
        return (ItemStack) this.itemStacks.get(p_38218_);
    }

    public ItemStack removeItem(int p_38220_, int p_38221_) {
        return ContainerHelper.removeItem(this.itemStacks, p_38220_, p_38221_);
    }

    public ItemStack removeItemNoUpdate(int p_38244_) {
        ItemStack itemstack = (ItemStack) this.itemStacks.get(p_38244_);
        if (itemstack.isEmpty()) {
            return ItemStack.EMPTY;
        }
        this.itemStacks.set(p_38244_, ItemStack.EMPTY);
        return itemstack;
    }

    public void setItem(int p_38225_, ItemStack p_38226_) {
        this.itemStacks.set(p_38225_, p_38226_);
        if (!p_38226_.isEmpty() && p_38226_.getCount() > getMaxStackSize()) {
            p_38226_.setCount(getMaxStackSize());
        }
    }

    public SlotAccess getSlot(final int p_150257_) {
        return (p_150257_ < 0 || p_150257_ >= getContainerSize()) ? super.getSlot(p_150257_) : new SlotAccess() { // from class: com.dairymoose.entity.MotorboatEntity.3
            public ItemStack get() {
                return MotorboatEntity.this.getItem(p_150257_);
            }

            public boolean set(ItemStack p_150265_) {
                MotorboatEntity.this.setItem(p_150257_, p_150265_);
                return true;
            }
        };
    }

    public void setChanged() {
    }

    public boolean stillValid(Player p_38230_) {
        return !isRemoved() && p_38230_.distanceToSqr(this) <= 64.0d;
    }

    public void remove(RemovalReason p_150255_) {
        if (!this.level.isClientSide && p_150255_.shouldDestroy()) {
            Containers.dropContents(this.level, this, this);
        }
        super.remove(p_150255_);
    }

    protected void addAdditionalSaveData(CompoundTag p_38248_) {
        if (p_38248_ != null) {
            ContainerHelper.saveAllItems(p_38248_, this.itemStacks);
            p_38248_.putFloat("FuelLevel", ((Float) this.entityData.get(DATA_ID_FUEL_LEVEL)).floatValue());
        }
    }

    protected void readAdditionalSaveData(CompoundTag p_38235_) {
        if (p_38235_ != null) {
            ContainerHelper.loadAllItems(p_38235_, this.itemStacks);
            this.entityData.set(DATA_ID_FUEL_LEVEL, Float.valueOf(p_38235_.getFloat("FuelLevel")));
        }
    }
}
