From f026ee9edb5672abd77093d1cc5f0d00a1bfe915 Mon Sep 17 00:00:00 2001 From: Thiago Santos Date: Thu, 1 May 2025 10:24:25 -0300 Subject: [PATCH 1/8] feat: creating compatibility layer --- settings.gradle | 0 .../java/com/alrex/parcool/api/Stamina.java | 8 +- .../AbstractClientPlayerWrapper.java | 26 ++ .../compatibility/ChannelInstanceWrapper.java | 11 + .../compatibility/ClientPlayerWrapper.java | 96 +++++ .../api/compatibility/EntityWrapper.java | 201 ++++++++++ .../api/compatibility/EventBusWrapper.java | 24 ++ .../compatibility/LivingEntityWrapper.java | 119 ++++++ .../compatibility/MinecraftServerWrapper.java | 89 +++++ .../PlayerPacketDistributor.java | 12 + .../api/compatibility/PlayerWrapper.java | 351 ++++++++++++++++++ .../compatibility/ServerPlayerWrapper.java | 87 +++++ .../parcool/api/compatibility/WeakCache.java | 23 ++ .../parcool/api/unstable/Limitation.java | 48 +-- .../unstable/action/ParCoolActionEvent.java | 16 +- .../animation/ParCoolAnimationInfoEvent.java | 8 +- .../parcool/client/animation/Animator.java | 18 +- .../animation/PassiveCustomAnimation.java | 24 +- .../client/animation/PlayerModelRotator.java | 6 +- .../animation/PlayerModelTransformer.java | 6 +- .../impl/BackwardWallJumpAnimator.java | 27 +- .../animation/impl/CatLeapAnimator.java | 7 +- .../animation/impl/ChargeJumpAnimator.java | 8 +- .../animation/impl/ClimbUpAnimator.java | 8 +- .../animation/impl/ClingToCliffAnimator.java | 8 +- .../client/animation/impl/CrawlAnimator.java | 6 +- .../impl/DiveAnimationHostAnimator.java | 30 +- .../animation/impl/DiveIntoWaterAnimator.java | 8 +- .../client/animation/impl/DodgeAnimator.java | 12 +- .../impl/ExaggeratedSideDodgeAnimator.java | 14 +- .../animation/impl/FastRunningAnimator.java | 12 +- .../animation/impl/FastSwimAnimator.java | 12 +- .../animation/impl/FlippingAnimator.java | 10 +- .../client/animation/impl/HangAnimator.java | 10 +- .../animation/impl/HideInBlockAnimator.java | 10 +- .../impl/HorizontalWallRunAnimator.java | 10 +- .../animation/impl/JumpChargingAnimator.java | 8 +- .../animation/impl/JumpFromBarAnimator.java | 8 +- .../animation/impl/KongVaultAnimator.java | 21 +- .../animation/impl/RideZiplineAnimator.java | 18 +- .../client/animation/impl/RollAnimator.java | 24 +- .../animation/impl/SlidingAnimator.java | 8 +- .../animation/impl/SpeedVaultAnimator.java | 11 +- .../client/animation/impl/TapAnimator.java | 8 +- .../impl/VerticalWallRunAnimator.java | 8 +- .../animation/impl/WallJumpAnimator.java | 8 +- .../animation/impl/WallSlideAnimator.java | 8 +- .../gui/SettingActionLimitationScreen.java | 5 +- .../gui/SettingBooleanConfigScreen.java | 5 +- .../client/gui/SettingEnumConfigScreen.java | 5 +- .../client/hud/impl/LightStaminaHUD.java | 10 +- .../parcool/client/hud/impl/StaminaHUD.java | 6 +- .../client/hud/impl/StaminaHUDController.java | 7 +- .../alrex/parcool/common/action/Action.java | 44 +-- .../common/action/ActionProcessor.java | 37 +- .../common/action/AdditionalProperties.java | 6 +- .../common/action/impl/BreakfallReady.java | 10 +- .../parcool/common/action/impl/CatLeap.java | 24 +- .../common/action/impl/ChargeJump.java | 52 ++- .../common/action/impl/ClimbPoles.java | 6 +- .../parcool/common/action/impl/ClimbUp.java | 10 +- .../common/action/impl/ClingToCliff.java | 26 +- .../parcool/common/action/impl/Crawl.java | 19 +- .../parcool/common/action/impl/Dive.java | 24 +- .../parcool/common/action/impl/Dodge.java | 20 +- .../parcool/common/action/impl/FastRun.java | 18 +- .../parcool/common/action/impl/FastSwim.java | 14 +- .../parcool/common/action/impl/Flipping.java | 12 +- .../parcool/common/action/impl/HangDown.java | 26 +- .../common/action/impl/HideInBlock.java | 54 +-- .../common/action/impl/HorizontalWallRun.java | 36 +- .../common/action/impl/JumpFromBar.java | 10 +- .../parcool/common/action/impl/QuickTurn.java | 12 +- .../common/action/impl/RideZipline.java | 27 +- .../parcool/common/action/impl/Roll.java | 27 +- .../parcool/common/action/impl/SkyDive.java | 26 +- .../parcool/common/action/impl/Slide.java | 24 +- .../alrex/parcool/common/action/impl/Tap.java | 16 +- .../parcool/common/action/impl/Vault.java | 14 +- .../common/action/impl/VerticalWallRun.java | 28 +- .../parcool/common/action/impl/WallJump.java | 34 +- .../parcool/common/action/impl/WallSlide.java | 33 +- .../block/zipline/IronZiplineHookBlock.java | 4 +- .../block/zipline/ZiplineHookBlock.java | 12 +- .../parcool/common/capability/Animation.java | 22 +- .../parcool/common/capability/IStamina.java | 16 +- .../common/capability/Parkourability.java | 8 +- .../capability/stamina/HungerStamina.java | 14 +- .../capability/stamina/OtherStamina.java | 10 +- .../common/capability/stamina/Stamina.java | 8 +- .../entity/zipline/ZiplineRopeEntity.java | 3 +- .../handlers/AttachCapabilityHandler.java | 7 +- .../EnableOrDisableParCoolHandler.java | 5 +- .../parcool/common/handlers/InputHandler.java | 5 +- .../common/handlers/LoginLogoutHandler.java | 8 +- .../handlers/OpenSettingsParCoolHandler.java | 4 +- .../common/handlers/PlayerCloneHandler.java | 20 +- .../common/handlers/PlayerDamageHandler.java | 45 ++- .../common/handlers/PlayerJoinHandler.java | 19 +- .../common/handlers/PlayerJumpHandler.java | 6 +- .../handlers/PlayerVisibilityHandler.java | 15 +- .../parcool/common/info/ServerLimitation.java | 4 +- .../common/item/zipline/ZiplineRopeItem.java | 20 +- .../common/network/StartBreakfallMessage.java | 15 +- .../network/SyncActionStateMessage.java | 25 +- .../network/SyncClientInformationMessage.java | 25 +- .../common/network/SyncServerInfoMessage.java | 26 +- .../common/network/SyncStaminaMessage.java | 18 +- .../alrex/parcool/common/zipline/Zipline.java | 6 +- .../BetterThirdPersonManager.java | 31 +- .../ShoulderSurfingManager.java | 31 +- .../mixin/client/ClientPlayerEntityMixin.java | 12 +- .../mixin/client/ClientWorldMixin.java | 5 +- .../mixin/client/PlayerModelMixin.java | 10 +- .../mixin/client/PlayerRendererMixin.java | 13 +- .../parcool/mixin/common/EntityMixin.java | 8 +- .../mixin/common/LivingEntityMixin.java | 24 +- .../mixin/common/PlayerEntityMixin.java | 9 +- .../impl/ControlLimitationCommand.java | 106 ++---- .../server/limitation/Limitations.java | 47 +-- .../parcool/utilities/BipedModelUtil.java | 7 +- .../alrex/parcool/utilities/EntityUtil.java | 6 +- .../parcool/utilities/JsonWriterUtil.java | 38 ++ .../alrex/parcool/utilities/WorldUtil.java | 135 ++++--- 124 files changed, 1984 insertions(+), 1090 deletions(-) create mode 100644 settings.gradle create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/AbstractClientPlayerWrapper.java create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/ChannelInstanceWrapper.java create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/ClientPlayerWrapper.java create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/EventBusWrapper.java create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/MinecraftServerWrapper.java create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/PlayerPacketDistributor.java create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/ServerPlayerWrapper.java create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/WeakCache.java create mode 100644 src/main/java/com/alrex/parcool/utilities/JsonWriterUtil.java diff --git a/settings.gradle b/settings.gradle new file mode 100644 index 00000000..e69de29b diff --git a/src/main/java/com/alrex/parcool/api/Stamina.java b/src/main/java/com/alrex/parcool/api/Stamina.java index c5120aaf..4098fc8d 100644 --- a/src/main/java/com/alrex/parcool/api/Stamina.java +++ b/src/main/java/com/alrex/parcool/api/Stamina.java @@ -1,7 +1,7 @@ package com.alrex.parcool.api; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.IStamina; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -9,11 +9,9 @@ public class Stamina { @Nullable - public static Stamina get(PlayerEntity player) { + public static Stamina get(PlayerWrapper player) { IStamina instance = IStamina.get(player); - if (instance == null) { - return null; - } + if (instance == null) return null; return new Stamina(instance); } diff --git a/src/main/java/com/alrex/parcool/api/compatibility/AbstractClientPlayerWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/AbstractClientPlayerWrapper.java new file mode 100644 index 00000000..bca2bc19 --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/AbstractClientPlayerWrapper.java @@ -0,0 +1,26 @@ +package com.alrex.parcool.api.compatibility; + +import net.minecraft.client.entity.player.AbstractClientPlayerEntity; +import net.minecraftforge.event.TickEvent.PlayerTickEvent; + +public class AbstractClientPlayerWrapper extends PlayerWrapper { + private AbstractClientPlayerEntity player; + private static final WeakCache cache = new WeakCache<>(); + + protected AbstractClientPlayerWrapper(AbstractClientPlayerEntity player) { + super(player); + this.player = player; + } + + public static AbstractClientPlayerWrapper get(AbstractClientPlayerEntity player) { + return cache.get(player, () -> new AbstractClientPlayerWrapper(player)); + } + + public static AbstractClientPlayerWrapper get(PlayerTickEvent event) { + return get((AbstractClientPlayerEntity)event.player); + } + + public AbstractClientPlayerEntity getInstance() { + return this.player; + } +} diff --git a/src/main/java/com/alrex/parcool/api/compatibility/ChannelInstanceWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/ChannelInstanceWrapper.java new file mode 100644 index 00000000..e82caf2e --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/ChannelInstanceWrapper.java @@ -0,0 +1,11 @@ +package com.alrex.parcool.api.compatibility; + +import com.alrex.parcool.ParCool; +import com.alrex.parcool.common.network.StartBreakfallMessage; +import net.minecraftforge.fml.network.PacketDistributor; + +public class ChannelInstanceWrapper { + public static void send(ServerPlayerWrapper player, StartBreakfallMessage message) { + ParCool.CHANNEL_INSTANCE.send(PacketDistributor.PLAYER.with(() -> player.getInstance()), message); + } +} diff --git a/src/main/java/com/alrex/parcool/api/compatibility/ClientPlayerWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/ClientPlayerWrapper.java new file mode 100644 index 00000000..0e9877e6 --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/ClientPlayerWrapper.java @@ -0,0 +1,96 @@ +package com.alrex.parcool.api.compatibility; + +import javax.annotation.Nullable; +import net.minecraft.client.Minecraft; +import net.minecraft.client.entity.player.AbstractClientPlayerEntity; +import net.minecraft.client.entity.player.ClientPlayerEntity; +import net.minecraft.entity.LivingEntity; +import net.minecraft.entity.player.PlayerEntity; + +public class ClientPlayerWrapper extends AbstractClientPlayerWrapper { + private static final Minecraft mc = Minecraft.getInstance(); + private ClientPlayerEntity player; + private static final WeakCache cache = new WeakCache<>(); + + public ClientPlayerWrapper(ClientPlayerEntity player) { + super(player); + this.player = player; + } + + // All static get methods grouped together + public static ClientPlayerWrapper get(ClientPlayerEntity player) { + return cache.get(player, () -> new ClientPlayerWrapper(player)); + } + + public static ClientPlayerWrapper get(PlayerEntity player) { + return get((ClientPlayerEntity)player); + } + + public static ClientPlayerWrapper get(PlayerWrapper player) { + ClientPlayerEntity clientPlayer = (ClientPlayerEntity) player.getInstance(); + return cache.get(clientPlayer, () -> new ClientPlayerWrapper(clientPlayer)); + } + + @Nullable + public static ClientPlayerWrapper get() { + return mc.player == null ? null : get(mc.player); + } + + public static ClientPlayerWrapper get(AbstractClientPlayerEntity player) { + return get((ClientPlayerEntity)player); + } + + public static ClientPlayerWrapper get(LivingEntity entity) { + return get((ClientPlayerEntity)entity); + } + + // All static getOrDefault methods grouped together + @Nullable + public static ClientPlayerWrapper getOrDefault(LivingEntity entity) { + return entity instanceof ClientPlayerEntity ? get(entity) : null; + } + + @Nullable + public static ClientPlayerWrapper getOrDefault(LivingEntityWrapper entityWrapper) { + return getOrDefault(entityWrapper.getInstance()); + } + + // All static is methods grouped together + public static boolean is(EntityWrapper playerWrapper) { + return playerWrapper.getInstance() instanceof ClientPlayerEntity; + } + + // All get methods grouped together + @Override + public ClientPlayerEntity getInstance() { + return player; + } + + public double getLeftImpulse() { + return player.input.leftImpulse; + } + + public double getForwardImpulse() { + return player.input.forwardImpulse; + } + + public long getGameTime() { + return player.level.getGameTime(); + } + + // All is/has methods grouped together + public boolean isSprinting() { + return player.isSprinting(); + } + + public boolean isAnyMoveKeyDown() { + return player.input.up + || player.input.down + || player.input.left + || player.input.right; + } + + public boolean hasForwardImpulse() { + return player.input.hasForwardImpulse(); + } +} diff --git a/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java new file mode 100644 index 00000000..ef8f34ea --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java @@ -0,0 +1,201 @@ +package com.alrex.parcool.api.compatibility; + +import java.util.UUID; + +import javax.annotation.Nonnull; + +import com.alrex.parcool.client.animation.PlayerModelRotator; +import net.minecraft.block.BlockState; +import net.minecraft.entity.Entity; +import net.minecraft.particles.BasicParticleType; +import net.minecraft.util.SoundEvent; +import net.minecraft.util.math.AxisAlignedBB; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.MathHelper; +import net.minecraft.util.math.vector.Vector3d; +import net.minecraft.world.World; +import net.minecraftforge.common.capabilities.Capability; +import net.minecraftforge.common.util.LazyOptional; + +public class EntityWrapper { + + private Entity entity; + protected static final WeakCache cache = new WeakCache<>(); + + protected EntityWrapper(Entity entity) { + this.entity = entity; + } + + // Static get methods + public static EntityWrapper get(Entity entity) { + return cache.get(entity, () -> new EntityWrapper(entity)); + } + + // add methods grouped together + public void addParticle(BasicParticleType endRod, double x, double d, double z, double e, double f, double g) { + entity.level.addParticle(endRod, x, d, z, e, f, g); + } + + public void addToDeltaMovement(int i, double d, int j) { + entity.setDeltaMovement(entity.getDeltaMovement().add(i, d, j)); + } + + public void addToDeltaMovement(Vector3d vec) { + entity.setDeltaMovement(entity.getDeltaMovement().add(vec)); + } + + // get methods grouped together + public BlockPos getAdjustedBlockPos(int xDirection, double minY, int zDirection) { + return new BlockPos( + entity.getX() + xDirection, + entity.getBoundingBox().minY + minY, + entity.getZ() + zDirection + ); + } + + public float getBbHeight() { + return entity.getBbHeight(); + } + + public float getBbWidth() { + return entity.getBbWidth(); + } + + public BlockState getBlockState(BlockPos pos) { + return entity.level.getBlockState(pos); + } + + public LazyOptional getCapability(@Nonnull final Capability cap) { + return entity.getCapability(cap); + } + + public Vector3d getDeltaMovement() { + return entity.getDeltaMovement(); + } + + public float getEyeHeight() { + return entity.getEyeHeight(); + } + + public float getFallDistance() { + return entity.fallDistance; + } + + public World getLevel() { + return entity.level; + } + + public Vector3d getLookAngle() { + return entity.getLookAngle(); + } + + public float getMinSlipperiness(BlockPos ...blockPos) { + float minSlipperiness = 1; + for (BlockPos pos : blockPos) { + if (entity.level.isLoaded(pos)) { + float candidateSlipperiness = entity.level.getBlockState(pos).getSlipperiness(entity.level, pos, entity); + minSlipperiness = Math.min(minSlipperiness, candidateSlipperiness); + } + } + return minSlipperiness; + } + + public float getRotatedYRot(PlayerModelRotator rotator) { + return 180f + MathHelper.lerp(rotator.getPartialTick(), entity.yRotO, entity.yRot); + } + + public int getTickCount() { + return entity.tickCount; + } + + public UUID getUUID() { + return entity.getUUID(); + } + + public float getViewXRot(float renderPartialTicks) { + return entity.getViewXRot(renderPartialTicks); + } + + public float getYHeadRot() { + return entity.getYHeadRot(); + } + + public float getYRot() { + return entity.yRot; + } + + public double getX() { + return entity.getX(); + } + + public double getY() { + return entity.getY(); + } + + public double getZ() { + return entity.getZ(); + } + + public Entity getInstance() { + return entity; + } + + // is methods grouped together + public boolean isEveryLoaded(BlockPos ...blockPos) { + for (BlockPos pos : blockPos) { + if (!entity.level.isLoaded(pos)) { + return false; + } + } + return true; + } + + public boolean isInLava() { + return entity.isInLava(); + } + + public boolean isInWaterOrBubble() { + return entity.isInWaterOrBubble(); + } + + public boolean isOnGround() { + return entity.isOnGround(); + } + + public boolean isVisuallyCrawling() { + return entity.isVisuallyCrawling(); + } + + public boolean isVisuallySwimming() { + return entity.isVisuallySwimming(); + } + + // Other methods + public void multiplyDeltaMovement(double d, int i, double e) { + entity.setDeltaMovement(entity.getDeltaMovement().multiply(d, i, e)); + } + + public boolean noCollision(AxisAlignedBB bb) { + return entity.level.noCollision(bb); + } + + public void playSound(SoundEvent soundEvent, float i, float j) { + entity.playSound(soundEvent, i, j); + } + + public Vector3d position() { + return entity.position(); + } + + public void resetFallDistance() { + entity.fallDistance = 0; + } + + public void setDeltaMovement(double x, double i, double z) { + entity.setDeltaMovement(x, i, z); + } + + public void setYBodyRot(float f) { + entity.setYBodyRot(f); + } +} diff --git a/src/main/java/com/alrex/parcool/api/compatibility/EventBusWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/EventBusWrapper.java new file mode 100644 index 00000000..c29cdd02 --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/EventBusWrapper.java @@ -0,0 +1,24 @@ +package com.alrex.parcool.api.compatibility; + +import com.alrex.parcool.api.unstable.action.ParCoolActionEvent; +import com.alrex.parcool.common.action.Action; + +import net.minecraftforge.common.MinecraftForge; + +public class EventBusWrapper { + public static boolean tryToStartEvent(PlayerWrapper player, Action action) { + return MinecraftForge.EVENT_BUS.post(new ParCoolActionEvent.TryToStartEvent(player, action)); + } + + public static boolean tryToContinueEvent(PlayerWrapper player, Action action) { + return MinecraftForge.EVENT_BUS.post(new ParCoolActionEvent.TryToContinueEvent(player, action)); + } + + public static boolean startEvent(PlayerWrapper player, Action action) { + return MinecraftForge.EVENT_BUS.post(new ParCoolActionEvent.StartEvent(player, action)); + } + + public static boolean stopEvent(PlayerWrapper player, Action action) { + return MinecraftForge.EVENT_BUS.post(new ParCoolActionEvent.StopEvent(player, action)); + } +} diff --git a/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java new file mode 100644 index 00000000..6f4d47b1 --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java @@ -0,0 +1,119 @@ +package com.alrex.parcool.api.compatibility; + +import java.util.Random; +import javax.annotation.Nonnull; + +import com.alrex.parcool.client.animation.PlayerModelRotator; +import com.alrex.parcool.utilities.MathUtil; +import com.alrex.parcool.utilities.VectorUtil; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.LivingEntity; +import net.minecraft.entity.ai.attributes.Attribute; +import net.minecraft.entity.ai.attributes.ModifiableAttributeInstance; +import net.minecraft.potion.Effect; +import net.minecraft.util.Hand; +import net.minecraft.util.HandSide; +import net.minecraft.util.math.AxisAlignedBB; +import net.minecraft.util.math.vector.Vector3d; +import net.minecraftforge.common.ForgeMod; +import net.minecraftforge.common.capabilities.Capability; +import net.minecraftforge.common.util.LazyOptional; + +public class LivingEntityWrapper extends EntityWrapper { + + private LivingEntity entity; + private static final WeakCache cache = new WeakCache<>(); + + protected LivingEntityWrapper(LivingEntity entity) { + super(entity); + this.entity = entity; + } + + // All get methods grouped together + @Override + public LivingEntity getInstance() { + return entity; + } + + public ModifiableAttributeInstance getAttribute(Attribute attribute) { + return entity.getAttribute(attribute); + } + + public double getAttributeValue(Attribute attribute) { + return entity.getAttributeValue(attribute); + } + + public AxisAlignedBB getBoundingBox() { + return entity.getBoundingBox(); + } + + public LazyOptional getCapability(@Nonnull final Capability cap) { + return entity.getCapability(cap); + } + + public double getGravity() { + return entity.getAttributeValue(ForgeMod.ENTITY_GRAVITY.get()); + } + + public HandSide getMainArm() { + return entity.getMainArm(); + } + + public Random getRandom() { + return entity.getRandom(); + } + + public Vector3d getRotatedBodyAngle(PlayerModelRotator rotator) { + return VectorUtil.fromYawDegree(MathUtil.lerp(entity.yBodyRotO, entity.yBodyRot, rotator.getPartialTick())); + } + + public double getUpdatedYRotDifference() { + Vector3d currentAngle = VectorUtil.fromYawDegree(entity.yBodyRot); + Vector3d oldAngle = VectorUtil.fromYawDegree(entity.yBodyRotO); + return Math.atan( + (oldAngle.x() * currentAngle.z() - currentAngle.x() * oldAngle.z()) + / (currentAngle.x() * oldAngle.x() + currentAngle.z() * oldAngle.z()) + ); + } + + public Vector3d getVectorYBodyRot() { + return VectorUtil.fromYawDegree(entity.yBodyRot); + } + + public float getYBodyRot() { + return entity.yBodyRot; + } + + // Static get methods + protected static LivingEntityWrapper get(LivingEntity entity) { + return cache.get(entity, () -> new LivingEntityWrapper(entity)); + } + + public static LivingEntityWrapper get(Entity entity) { + return get((LivingEntity)entity); + } + + // Has/is boolean methods + public boolean hasEffect(Effect effect) { + return entity.hasEffect(effect); + } + + public boolean isFallFlying() { + return entity.isFallFlying(); + } + + public boolean isSpectator() { + return entity.isSpectator(); + } + + public boolean isSwingingMainHand() { + return entity.swingingArm == Hand.MAIN_HAND; + } + + // Update methods + public void updateBodyRot() { + entity.yBodyRot = entity.yRot; + entity.yBodyRotO = entity.yRotO; + } +} diff --git a/src/main/java/com/alrex/parcool/api/compatibility/MinecraftServerWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/MinecraftServerWrapper.java new file mode 100644 index 00000000..b1d6bfc0 --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/MinecraftServerWrapper.java @@ -0,0 +1,89 @@ +package com.alrex.parcool.api.compatibility; + +import java.util.Iterator; +import java.util.UUID; + +import javax.annotation.Nullable; + +import com.mojang.brigadier.context.CommandContext; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.world.ClientWorld; +import net.minecraft.command.CommandSource; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.entity.player.ServerPlayerEntity; +import net.minecraft.server.MinecraftServer; + +public class MinecraftServerWrapper { + private final MinecraftServer instance; + private static Minecraft mc = Minecraft.getInstance(); + + public MinecraftServerWrapper(MinecraftServer server) { + this.instance = server; + } + + // All get methods grouped together + public static MinecraftServerWrapper get(CommandContext context) { + return new MinecraftServerWrapper(context.getSource().getServer()); + } + + @Nullable + public static PlayerWrapper getPlayer(UUID playerID) { + ClientWorld level = mc.level; + if (level == null) return null; + PlayerEntity playerEntity = level.getPlayerByUUID(playerID); + if (playerEntity == null) return null; + return PlayerWrapper.get(playerEntity); + } + + // All getPlayers methods grouped together + public Iterable getServerPlayers() { + return getServerPlayers(instance.getPlayerList().getPlayers()); + } + + public static Iterable getPlayers(CommandContext context) { + return getServerPlayers(context.getSource().getServer().getPlayerList().getPlayers()); + } + + public static Iterable getServerPlayers(Iterable iterable) { + Iterator iterator = iterable.iterator(); + return new Iterable() { + @Override + public Iterator iterator() { + return new Iterator() { + + @Override + public boolean hasNext() { + return iterator.hasNext(); + } + + @Override + public ServerPlayerWrapper next() { + return ServerPlayerWrapper.get(iterator.next()); + } + }; + } + }; + } + + public static Iterable getPlayers(Iterable iterable) { + Iterator iterator = iterable.iterator(); + return new Iterable() { + @Override + public Iterator iterator() { + return new Iterator() { + + @Override + public boolean hasNext() { + return iterator.hasNext(); + } + + @Override + public PlayerWrapper next() { + return PlayerWrapper.get(iterator.next()); + } + }; + } + }; + } +} diff --git a/src/main/java/com/alrex/parcool/api/compatibility/PlayerPacketDistributor.java b/src/main/java/com/alrex/parcool/api/compatibility/PlayerPacketDistributor.java new file mode 100644 index 00000000..ff96aaa8 --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/PlayerPacketDistributor.java @@ -0,0 +1,12 @@ +package com.alrex.parcool.api.compatibility; + +import net.minecraft.entity.player.ServerPlayerEntity; +import net.minecraftforge.fml.network.PacketDistributor; +import net.minecraftforge.fml.network.PacketDistributor.PacketTarget; + +public class PlayerPacketDistributor { + public static PacketTarget with(ServerPlayerWrapper player) { + ServerPlayerEntity instance = player.getInstance(); + return PacketDistributor.PLAYER.with(() -> instance); + } +} diff --git a/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java new file mode 100644 index 00000000..dddb6977 --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java @@ -0,0 +1,351 @@ +package com.alrex.parcool.api.compatibility; + +import java.util.UUID; +import java.util.function.Consumer; +import java.util.function.Supplier; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; + +import com.alrex.parcool.utilities.VectorUtil; + +import net.minecraft.block.BlockState; +import net.minecraft.entity.Entity; +import net.minecraft.entity.LivingEntity; +import net.minecraft.entity.Pose; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.item.BlockItemUseContext; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemUseContext; +import net.minecraft.potion.Effect; +import net.minecraft.util.DamageSource; +import net.minecraft.util.Hand; +import net.minecraft.util.SoundEvent; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.vector.Vector3d; +import net.minecraft.util.text.IFormattableTextComponent; +import net.minecraft.world.World; +import net.minecraftforge.common.capabilities.Capability; +import net.minecraftforge.common.capabilities.CapabilityProvider; +import net.minecraftforge.common.util.LazyOptional; +import net.minecraftforge.event.AttachCapabilitiesEvent; +import net.minecraftforge.event.TickEvent.PlayerTickEvent; +import net.minecraftforge.event.entity.living.LivingEvent; +import net.minecraftforge.event.entity.living.LivingEvent.LivingJumpEvent; +import net.minecraftforge.event.entity.living.LivingFallEvent; +import net.minecraftforge.event.entity.player.PlayerEvent; +import net.minecraftforge.event.entity.player.PlayerEvent.Clone; +import net.minecraftforge.fml.network.NetworkEvent.Context; + +public class PlayerWrapper extends LivingEntityWrapper { + + private PlayerEntity player; + protected static final WeakCache cache = new WeakCache<>(); + + public PlayerWrapper(PlayerEntity player) { + super(player); + this.player = player; + } + + // All get methods grouped together + @Override + public PlayerEntity getInstance() { + return player; + } + + public BlockState getBelowBlockState() { + return player.level.getBlockState(player.blockPosition().below()); + } + + public float getEyeHeight() { + return player.getEyeHeight(Pose.STANDING); + } + + public float getFallDistance() { + return player.fallDistance; + } + + public int getFoodLevel() { + return player.getFoodData().getFoodLevel(); + } + + public ItemStack getItemInHand(Hand hand) { + return player.getItemInHand(hand); + } + + public String getName() { + return player.getGameProfile().getName(); + } + + public Pose getPose() { + return player.getPose(); + } + + public float getSlipperiness(BlockPos leanedBlock) { + return player.level.getBlockState(leanedBlock).getSlipperiness(player.level, leanedBlock, player); + } + + public int getTickCount() { + return player.tickCount; + } + + public Object getVehicle() { + return player.getVehicle(); + } + + public LazyOptional getCapability(@Nonnull final Capability cap) { + return player.getCapability(cap); + } + + public Iterable getPlayersOnSameLevel() { + return MinecraftServerWrapper.getPlayers(player.level.players()); + } + + // All static get methods grouped together + public static PlayerWrapper get(PlayerEntity player) { + return cache.get(player, () -> new PlayerWrapper(player)); + } + + public static PlayerWrapper get(PlayerTickEvent event) { + return get(event.player); + } + + public static PlayerWrapper get(AttachCapabilitiesEvent event) { + return get((PlayerEntity) event.getObject()); + } + + public static PlayerWrapper get(PlayerEvent event) { + return get(event.getPlayer()); + } + + public static PlayerWrapper get(Entity entity) { + return get((PlayerEntity)entity); + } + + public static PlayerWrapper get(ItemUseContext context) { + return get(context.getPlayer()); + } + + public static PlayerWrapper get(LivingEntity entity) { + return get((PlayerEntity)entity); + } + + public static PlayerWrapper get(LivingEntityWrapper entity) { + return get((PlayerEntity)entity.getInstance()); + } + + public static PlayerWrapper get(CapabilityProvider entityMixin) { + return get((PlayerEntity)(Object)entityMixin); + } + + public static PlayerWrapper get(Supplier contextSupplier) { + return get(contextSupplier.get().getSender()); + } + + @Nullable + public static PlayerWrapper get(World world, UUID playerID) { + PlayerEntity playerEntity = world.getPlayerByUUID(playerID); + if (playerEntity == null) return null; + return PlayerWrapper.get(playerEntity); + } + + // All getOrDefault methods grouped + @Nullable + public static PlayerWrapper getOrDefault(AttachCapabilitiesEvent event) { + return getOrDefault(event.getObject()); + } + + @Nullable + public static PlayerWrapper getOrDefault(Entity entity) { + return entity instanceof PlayerEntity ? get(entity) : null; + } + + public static PlayerWrapper getOrDefault(LivingEntityWrapper entity) { + return getOrDefault(entity.getInstance()); + } + + // All getFrom methods grouped + public static PlayerWrapper getOriginalPlayer(Clone event) { + return get(event.getOriginal()); + } + + public static PlayerWrapper getFromLivingEntity(LivingEvent event) { + return get((PlayerEntity)event.getEntityLiving()); + } + + public static PlayerWrapper getFromEntity(LivingEvent event) { + return get((PlayerEntity)event.getEntity()); + } + + public static PlayerWrapper getFromEntityOrDefault(LivingFallEvent event) { + Entity entity = event.getEntity(); + return entity instanceof PlayerEntity ? get((PlayerEntity)entity) : null; + } + + public static PlayerWrapper getFromEntityOrDefault(LivingEvent event) { + return getOrDefault(event.getEntity()); + } + + // All has/is boolean methods grouped + public boolean hasEffect(Effect effect) { + return player.hasEffect(effect); + } + + public boolean hasHurtTime() { + return player.hurtTime > 0; + } + + public boolean hasNoPhysics() { + return player.noPhysics; + } + + public boolean hasSomeCollision() { + return player.horizontalCollision || player.verticalCollision; + } + + public boolean isCreative() { + return player.isCreative(); + } + + public boolean isCrouching() { + return player.isCrouching(); + } + + public boolean isFallFlying() { + return player.isFallFlying(); + } + + public boolean isFlying() { + return player.abilities.flying; + } + + public boolean isImmortal() { + return player.isSpectator() || player.isCreative(); + } + + public boolean isInWall() { + return player.isInWall(); + } + + public boolean isInWater() { + return player.isInWater(); + } + + public boolean isLevelClientSide() { + return player.level.isClientSide; + } + + public boolean isLocalPlayer() { + return player.isLocalPlayer(); + } + + public boolean isOnGround() { + return player.isOnGround(); + } + + public boolean isPassenger() { + return player.isPassenger(); + } + + public boolean isShiftKeyDown() { + return player.isShiftKeyDown(); + } + + public boolean isSprinting() { + return player.isSprinting(); + } + + public boolean isSwimming() { + return player.isSwimming(); + } + + public static boolean is(LivingEntityWrapper entity) { + return entity.getInstance() instanceof PlayerEntity; + } + + public boolean onClimbable() { + return player.onClimbable(); + } + + // All set methods grouped + public void setAllYBodyRot(float bodyYaw) { + player.yBodyRot = bodyYaw; + player.yBodyRotO = bodyYaw; + } + + public void setDeltaMovement(Vector3d vec) { + player.setDeltaMovement(vec); + } + + public void setPos(Vector3d hidingPoint) { + player.setPos(hidingPoint.x(), hidingPoint.y(), hidingPoint.z()); + } + + public void setSprinting(boolean b) { + player.setSprinting(true); + } + + public void setStandingPose() { + player.setPose(Pose.STANDING); + } + + public void setSwimming() { + player.setSprinting(false); + player.setPose(Pose.SWIMMING); + } + + public void setYHeadRot(float yawDegree) { + player.yHeadRot = yawDegree; + } + + public void setYRot(double yawDegree) { + player.yRot = (float)yawDegree; + } + + // All hurt methods grouped + public void hurtAndBreakStack(int quantity, ItemStack stack) { + hurtAndBreakStack(quantity, stack, (it) -> { + // Do nothing + }); + } + + public void hurtAndBreakStack(int quantity, ItemStack stack, Consumer consumer) { + stack.hurtAndBreak(quantity, player, (it) -> consumer.accept(get(it))); + } + + // Remaining methods + public void displayClientMessage(IFormattableTextComponent translationTextComponent, boolean b) { + player.displayClientMessage(translationTextComponent, b); + } + + public void disablePhysics() { + player.noPhysics = true; + } + + public void enablePhysics() { + player.noPhysics = false; + } + + public void forceDamage(DamageSource source, float f) { + int invulnerableTime = player.invulnerableTime; // bypass invulnerableTime + player.invulnerableTime = 0; + player.hurt(source, f); + player.invulnerableTime = invulnerableTime; + } + + public void jumpFromGround() { + player.jumpFromGround(); + } + + public void multiplyFallDistance(float multiplier) { + player.fallDistance *= multiplier; + } + + public void playSound(SoundEvent soundEvent, float i, float j) { + player.playSound(soundEvent, i, j); + } + + public void rotateBodyRot0(Vector3d direction, double d) { + player.yBodyRotO = player.yBodyRot = (float) VectorUtil.toYawDegree(direction.yRot((float) d)); + } +} diff --git a/src/main/java/com/alrex/parcool/api/compatibility/ServerPlayerWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/ServerPlayerWrapper.java new file mode 100644 index 00000000..f8b0da8c --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/ServerPlayerWrapper.java @@ -0,0 +1,87 @@ +package com.alrex.parcool.api.compatibility; + +import java.util.function.Supplier; +import javax.annotation.Nullable; +import com.mojang.brigadier.context.CommandContext; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import net.minecraft.command.CommandSource; +import net.minecraft.command.arguments.EntityArgument; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.ServerPlayerEntity; +import net.minecraftforge.event.entity.living.LivingEvent; +import net.minecraftforge.event.entity.living.LivingFallEvent; +import net.minecraftforge.event.entity.player.PlayerEvent.Clone; +import net.minecraftforge.fml.network.NetworkEvent.Context; + +public class ServerPlayerWrapper extends PlayerWrapper { + + private ServerPlayerEntity player; + private static final WeakCache cache = new WeakCache(); + + private ServerPlayerWrapper(ServerPlayerEntity player) { + super(player); + this.player = player; + } + + // All static get methods grouped together + public static ServerPlayerWrapper get(ServerPlayerEntity player) { + return cache.get(player, () -> new ServerPlayerWrapper(player)); + } + + public static ServerPlayerWrapper get(Supplier contextSupplier) { + return new ServerPlayerWrapper(contextSupplier.get().getSender()); + } + + public static ServerPlayerWrapper get(LivingFallEvent event) { + return get((ServerPlayerEntity)event.getEntityLiving()); + } + + public static ServerPlayerWrapper get(Entity entity) { + return get((ServerPlayerEntity)entity); + } + + @Nullable + public static ServerPlayerWrapper getPlayer(CommandContext context, String arg) + throws CommandSyntaxException + { + @Nullable ServerPlayerEntity player = EntityArgument.getPlayer(context, arg); + return player == null ? null : new ServerPlayerWrapper(player); + } + + // All getFrom methods grouped together + public static ServerPlayerWrapper getFromEntity(LivingEvent event) { + return get((ServerPlayerEntity)event.getEntity()); + } + + public static ServerPlayerWrapper getFromEntityOrDefault(LivingFallEvent event) { + Entity entity = event.getEntity(); + return entity instanceof ServerPlayerEntity + ? get((ServerPlayerEntity)entity) + : null; + } + + // All getOrDefault methods grouped together + @Nullable + public static ServerPlayerWrapper getOrDefault(Entity entity) { + return entity instanceof ServerPlayerEntity ? get(entity) : null; + } + + public static ServerPlayerWrapper getOrDefault(Clone event) { + return getOrDefault(event.getPlayer()); + } + + // All is methods grouped together + public static boolean is(PlayerWrapper player) { + return player.getInstance() instanceof ServerPlayerEntity; + } + + // Instance methods + @Override + public ServerPlayerEntity getInstance() { + return player; + } + + public void causeFoodExhaustion(float f) { + player.causeFoodExhaustion(f); + } +} diff --git a/src/main/java/com/alrex/parcool/api/compatibility/WeakCache.java b/src/main/java/com/alrex/parcool/api/compatibility/WeakCache.java new file mode 100644 index 00000000..896964d2 --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/WeakCache.java @@ -0,0 +1,23 @@ +package com.alrex.parcool.api.compatibility; + +import java.util.Map; +import java.util.WeakHashMap; + +import com.google.common.base.Supplier; + +public class WeakCache { + private final Map, WeakHashMap> cache = new WeakHashMap<>(); + + public V get(K key, Supplier create) { + WeakHashMap hashMap = cache.get(key.getClass()); + if (hashMap == null) { + hashMap = new WeakHashMap<>(); + cache.put(key.getClass(), hashMap); + } + V value = hashMap.get(key); + if (value != null) return value; + value = create.get(); + hashMap.put(key, value); + return value; + } +} diff --git a/src/main/java/com/alrex/parcool/api/unstable/Limitation.java b/src/main/java/com/alrex/parcool/api/unstable/Limitation.java index 92404adc..fe11c6bc 100644 --- a/src/main/java/com/alrex/parcool/api/unstable/Limitation.java +++ b/src/main/java/com/alrex/parcool/api/unstable/Limitation.java @@ -1,32 +1,25 @@ package com.alrex.parcool.api.unstable; import com.alrex.parcool.ParCool; +import com.alrex.parcool.api.compatibility.MinecraftServerWrapper; +import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.server.limitation.Limitations; -import com.google.gson.stream.JsonWriter; -import net.minecraft.entity.player.ServerPlayerEntity; -import net.minecraft.server.MinecraftServer; - -import java.io.BufferedOutputStream; +import com.alrex.parcool.utilities.JsonWriterUtil; import java.io.File; -import java.io.IOException; -import java.io.OutputStreamWriter; -import java.nio.charset.StandardCharsets; -import java.nio.file.Files; import java.nio.file.Path; -import java.nio.file.StandardOpenOption; public abstract class Limitation { - public static Limitation get(ServerPlayerEntity player, ID limitationID) { + public static Limitation get(ServerPlayerWrapper player, ID limitationID) { return new NormalLimitation(player, Limitations.createLimitationOf(player.getUUID(), limitationID.convert())); } - public static Limitation getIndividual(ServerPlayerEntity player) { + public static Limitation getIndividual(ServerPlayerWrapper player) { return new NormalLimitation(player, Limitations.createLimitationOf(player.getUUID(), Limitations.INDIVIDUAL_ID)); } - public static Limitation getGlobal(MinecraftServer server) { + public static Limitation getGlobal(MinecraftServerWrapper server) { return new GlobalLimitation(server); } @@ -131,12 +124,12 @@ public static boolean delete(ID limitationID) { private static class NormalLimitation extends Limitation { - private NormalLimitation(ServerPlayerEntity player, com.alrex.parcool.server.limitation.Limitation instance) { + private NormalLimitation(ServerPlayerWrapper player, com.alrex.parcool.server.limitation.Limitation instance) { super(instance); this.player = player; } - private final ServerPlayerEntity player; + private final ServerPlayerWrapper player; @Override public void apply() { @@ -162,37 +155,22 @@ public void save() { if (!limitationFile.getParentFile().exists()) { limitationFile.getParentFile().mkdirs(); } - try (JsonWriter writer = - new JsonWriter( - new OutputStreamWriter( - new BufferedOutputStream( - Files.newOutputStream(limitationFile.toPath(), StandardOpenOption.CREATE, StandardOpenOption.WRITE) - ), - StandardCharsets.UTF_8 - ) - ) - ) { - instance.saveTo(writer); - } catch (IOException e) { - ParCool.LOGGER.error( - "IOException during saving limitation : " - + e.getMessage() - ); - } + + JsonWriterUtil.Save(instance, limitationFile); } } private static class GlobalLimitation extends Limitation { - private final MinecraftServer server; + private final MinecraftServerWrapper server; - private GlobalLimitation(MinecraftServer server) { + private GlobalLimitation(MinecraftServerWrapper server) { super(Limitations.getGlobalLimitation()); this.server = server; } @Override public void apply() { - for (ServerPlayerEntity player : server.getPlayerList().getPlayers()) { + for (ServerPlayerWrapper player : server.getServerPlayers()) { Limitations.updateOnlyLimitation(player); } } diff --git a/src/main/java/com/alrex/parcool/api/unstable/action/ParCoolActionEvent.java b/src/main/java/com/alrex/parcool/api/unstable/action/ParCoolActionEvent.java index 498d5dce..41e5952a 100644 --- a/src/main/java/com/alrex/parcool/api/unstable/action/ParCoolActionEvent.java +++ b/src/main/java/com/alrex/parcool/api/unstable/action/ParCoolActionEvent.java @@ -1,15 +1,15 @@ package com.alrex.parcool.api.unstable.action; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.Action; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.eventbus.api.Cancelable; import net.minecraftforge.eventbus.api.Event; public class ParCoolActionEvent extends Event { - private final PlayerEntity player; + private final PlayerWrapper player; private final Action action; - public PlayerEntity getPlayer() { + public PlayerWrapper getPlayer() { return player; } @@ -17,7 +17,7 @@ public Action getAction() { return action; } - public ParCoolActionEvent(PlayerEntity player, Action action) { + public ParCoolActionEvent(PlayerWrapper player, Action action) { this.player = player; this.action = action; } @@ -30,7 +30,7 @@ public boolean isCancelable() { return true; } - public TryToStartEvent(PlayerEntity player, Action action) { + public TryToStartEvent(PlayerWrapper player, Action action) { super(player, action); } } @@ -43,19 +43,19 @@ public boolean isCancelable() { return true; } - public TryToContinueEvent(PlayerEntity player, Action action) { + public TryToContinueEvent(PlayerWrapper player, Action action) { super(player, action); } } public static class StartEvent extends ParCoolActionEvent { - public StartEvent(PlayerEntity player, Action action) { + public StartEvent(PlayerWrapper player, Action action) { super(player, action); } } public static class StopEvent extends ParCoolActionEvent { - public StopEvent(PlayerEntity player, Action action) { + public StopEvent(PlayerWrapper player, Action action) { super(player, action); } } diff --git a/src/main/java/com/alrex/parcool/api/unstable/animation/ParCoolAnimationInfoEvent.java b/src/main/java/com/alrex/parcool/api/unstable/animation/ParCoolAnimationInfoEvent.java index b56a2109..8f942930 100644 --- a/src/main/java/com/alrex/parcool/api/unstable/animation/ParCoolAnimationInfoEvent.java +++ b/src/main/java/com/alrex/parcool/api/unstable/animation/ParCoolAnimationInfoEvent.java @@ -1,19 +1,19 @@ package com.alrex.parcool.api.unstable.animation; +import com.alrex.parcool.api.compatibility.AbstractClientPlayerWrapper; import com.alrex.parcool.client.animation.Animator; -import net.minecraft.client.entity.player.AbstractClientPlayerEntity; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.eventbus.api.Event; @OnlyIn(Dist.CLIENT) public class ParCoolAnimationInfoEvent extends Event { - private final AbstractClientPlayerEntity player; + private final AbstractClientPlayerWrapper player; private final Animator animator; private final AnimationOption option; public ParCoolAnimationInfoEvent( - AbstractClientPlayerEntity player, + AbstractClientPlayerWrapper player, Animator animator ) { this.animator = animator; @@ -21,7 +21,7 @@ public ParCoolAnimationInfoEvent( option = new AnimationOption(); } - public AbstractClientPlayerEntity getPlayer() { + public AbstractClientPlayerWrapper getPlayer() { return player; } diff --git a/src/main/java/com/alrex/parcool/client/animation/Animator.java b/src/main/java/com/alrex/parcool/client/animation/Animator.java index c1404ee7..333ae58f 100644 --- a/src/main/java/com/alrex/parcool/client/animation/Animator.java +++ b/src/main/java/com/alrex/parcool/client/animation/Animator.java @@ -1,14 +1,14 @@ package com.alrex.parcool.client.animation; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.client.event.EntityViewRenderEvent; import net.minecraftforge.event.TickEvent; public abstract class Animator { private int tick = 0; - public void tick(PlayerEntity player) { + public void tick(PlayerWrapper player) { tick++; } @@ -16,13 +16,13 @@ protected int getTick() { return tick; } - public abstract boolean shouldRemoved(PlayerEntity player, Parkourability parkourability); + public abstract boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability); /** * @return You should return true if you want to cancel vanilla animation to control all about rendering */ public boolean animatePre( - PlayerEntity player, + PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer ) { @@ -34,14 +34,14 @@ public boolean animatePre( * You can utilize this to use partially vanilla animation */ public void animatePost( - PlayerEntity player, + PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer ) { } public boolean rotatePre( - PlayerEntity player, + PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator ) { @@ -49,7 +49,7 @@ public boolean rotatePre( } public void rotatePost( - PlayerEntity player, + PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator ) { @@ -57,14 +57,14 @@ public void rotatePost( public void onCameraSetUp( EntityViewRenderEvent.CameraSetup event, - PlayerEntity clientPlayer, + PlayerWrapper clientPlayer, Parkourability parkourability ) { } public void onRenderTick( TickEvent.RenderTickEvent event, - PlayerEntity player, + PlayerWrapper player, Parkourability parkourability ) { } diff --git a/src/main/java/com/alrex/parcool/client/animation/PassiveCustomAnimation.java b/src/main/java/com/alrex/parcool/client/animation/PassiveCustomAnimation.java index 87d672a8..821c440f 100644 --- a/src/main/java/com/alrex/parcool/client/animation/PassiveCustomAnimation.java +++ b/src/main/java/com/alrex/parcool/client/animation/PassiveCustomAnimation.java @@ -1,5 +1,6 @@ package com.alrex.parcool.client.animation; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.impl.ClingToCliff; import com.alrex.parcool.common.action.impl.Dive; @@ -8,7 +9,6 @@ import com.alrex.parcool.utilities.EasingFunctions; import com.alrex.parcool.utilities.MathUtil; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.World; @@ -22,9 +22,9 @@ public class PassiveCustomAnimation { private int flyingAnimationLevel = 0; private static final int flyingMaxLevel = 20; - public void tick(PlayerEntity player, Parkourability parkourability) { + public void tick(PlayerWrapper player, Parkourability parkourability) { flyingAnimationLevelOld = flyingAnimationLevel; - if (KeyBindings.isKeyForwardDown() && player.abilities.flying) { + if (KeyBindings.isKeyForwardDown() && player.isFlying()) { flyingAnimationLevel++; if (flyingAnimationLevel > flyingMaxLevel) { flyingAnimationLevel = flyingMaxLevel; @@ -36,8 +36,8 @@ public void tick(PlayerEntity player, Parkourability parkourability) { } } if (!player.isOnGround() - && player.fallDistance > 1 - && !player.abilities.flying + && player.getFallDistance() > 1f + && !player.isFlying() && !player.isFallFlying() && !parkourability.get(ClingToCliff.class).isDoing() ) { @@ -53,7 +53,7 @@ public void tick(PlayerEntity player, Parkourability parkourability) { */ } - public void animate(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animate(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { if (fallingAnimationTick >= FallingStartLine && ParCoolConfig.Client.Booleans.EnableFallingAnimation.get() && !parkourability.get(Dive.class).isDoing() @@ -62,7 +62,7 @@ public void animate(PlayerEntity player, Parkourability parkourability, PlayerMo } } - public void rotate(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotate(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { } private void animateFalling(Parkourability parkourability, PlayerModelTransformer transformer) { @@ -78,7 +78,7 @@ private void animateFalling(Parkourability parkourability, PlayerModelTransforme .end(); } - private void animateCreativeFlying(PlayerEntity player, PlayerModelTransformer transformer) { + private void animateCreativeFlying(PlayerWrapper player, PlayerModelTransformer transformer) { float angle = getAngleCreativeFlying(player, transformer.getPartialTick()); float factor = getFactorCreativeFlying(transformer.getPartialTick()); if (flyingAnimationLevel > 0) { @@ -100,15 +100,15 @@ private void animateCreativeFlying(PlayerEntity player, PlayerModelTransformer t } } - private void rotateCreativeFlying(PlayerEntity player, PlayerModelRotator rotator) { + private void rotateCreativeFlying(PlayerWrapper player, PlayerModelRotator rotator) { rotator .startBasedCenter() .rotatePitchFrontward(getAngleCreativeFlying(player, rotator.getPartialTick())) .end(); } - private void spawnSweatParticle(PlayerEntity player) { - World level = player.level; + private void spawnSweatParticle(PlayerWrapper player) { + World level = player.getLevel(); Random rand = player.getRandom(); Vector3d particleSpeed = player.getDeltaMovement().scale(0.6); level.addParticle( @@ -121,7 +121,7 @@ private void spawnSweatParticle(PlayerEntity player) { particleSpeed.z() ); } - private float getAngleCreativeFlying(PlayerEntity player, float partial) { + private float getAngleCreativeFlying(PlayerWrapper player, float partial) { float xRot = (float) VectorUtil.toPitchDegree(player.getDeltaMovement()); return (xRot + 90) * getFactorCreativeFlying(partial); } diff --git a/src/main/java/com/alrex/parcool/client/animation/PlayerModelRotator.java b/src/main/java/com/alrex/parcool/client/animation/PlayerModelRotator.java index 95644a5e..10765799 100644 --- a/src/main/java/com/alrex/parcool/client/animation/PlayerModelRotator.java +++ b/src/main/java/com/alrex/parcool/client/animation/PlayerModelRotator.java @@ -1,13 +1,13 @@ package com.alrex.parcool.client.animation; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.unstable.animation.AnimationOption; import com.mojang.blaze3d.matrix.MatrixStack; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.vector.Vector3f; public class PlayerModelRotator { private final MatrixStack stack; - private final PlayerEntity player; + private final PlayerWrapper player; private final float partial; private AnimationOption option = new AnimationOption(); private double playerHeight = 1.8; @@ -32,7 +32,7 @@ public float getPartialTick() { private boolean basedCenter = false; private boolean basedTop = false; - public PlayerModelRotator(MatrixStack stack, PlayerEntity player, float partial, float xRot, float yRot, float zRot) { + public PlayerModelRotator(MatrixStack stack, PlayerWrapper player, float partial, float xRot, float yRot, float zRot) { this.stack = stack; this.player = player; this.partial = partial; diff --git a/src/main/java/com/alrex/parcool/client/animation/PlayerModelTransformer.java b/src/main/java/com/alrex/parcool/client/animation/PlayerModelTransformer.java index d6438cc1..904f5a6b 100644 --- a/src/main/java/com/alrex/parcool/client/animation/PlayerModelTransformer.java +++ b/src/main/java/com/alrex/parcool/client/animation/PlayerModelTransformer.java @@ -1,5 +1,6 @@ package com.alrex.parcool.client.animation; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.unstable.animation.AnimationOption; import com.alrex.parcool.api.unstable.animation.AnimationPart; import com.alrex.parcool.utilities.MathUtil; @@ -7,14 +8,13 @@ import net.minecraft.client.renderer.entity.model.PlayerModel; import net.minecraft.client.renderer.model.ModelHelper; import net.minecraft.client.renderer.model.ModelRenderer; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.MathHelper; /** * Using Radians */ public class PlayerModelTransformer { - private final PlayerEntity player; + private final PlayerWrapper player; private final PlayerModel model; private final float partial; private final float ageInTicks; @@ -49,7 +49,7 @@ public PlayerModel getRawModel() { } public PlayerModelTransformer( - PlayerEntity player, + PlayerWrapper player, PlayerModel model, boolean slim, float ageInTicks, diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/BackwardWallJumpAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/BackwardWallJumpAnimator.java index c35e0f68..2d45a2ca 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/BackwardWallJumpAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/BackwardWallJumpAnimator.java @@ -1,5 +1,6 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -8,33 +9,25 @@ import com.alrex.parcool.utilities.EasingFunctions; import com.alrex.parcool.utilities.MathUtil; import net.minecraft.client.Minecraft; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.client.event.EntityViewRenderEvent; public class BackwardWallJumpAnimator extends Animator { private final int maxTick = 12; @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return getTick() >= maxTick; } private float armAngleXFactorBack(float phase) { - if (phase < 0.1) { - return 1 - 100 * (phase - 0.1f) * (phase - 0.1f); - } else if (phase < 0.6) { - return 1 - EasingFunctions.SinInOutBySquare((phase - 0.1f) * 2); - } else { - return 0.1f * EasingFunctions.SinInOutBySquare((phase - 0.6f) * 2.5f); - } + if (phase < 0.1) return 1 - 100 * (phase - 0.1f) * (phase - 0.1f); + if (phase < 0.6) return 1 - EasingFunctions.SinInOutBySquare((phase - 0.1f) * 2); + return 0.1f * EasingFunctions.SinInOutBySquare((phase - 0.6f) * 2.5f); } private float legAngleFactorBack(float phase) { - if (phase < 0.5) { - return 8 * (phase - 0.25f) * (phase - 0.25f); - } else { - return 1 - 8 * (phase - 0.75f) * (phase - 0.75f); - } + if (phase < 0.5) return 8 * (phase - 0.25f) * (phase - 0.25f); + return 1 - 8 * (phase - 0.75f) * (phase - 0.75f); } private float armAngleZFactor(float phase) { @@ -61,7 +54,7 @@ private float getAnimationFactor(float phase) { } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float phase = (getTick() + transformer.getPartialTick()) / maxTick; float armAngleX = MathUtil.lerp(20, -190, armAngleXFactorBack(phase)); float armAngleZ = MathUtil.lerp(phase > 0.75 ? 0 : 14, 28, armAngleZFactor(phase)); @@ -100,7 +93,7 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float phase = (getTick() + rotator.getPartialTick()) / maxTick; float factor = angleFactor(phase); @@ -111,7 +104,7 @@ public void rotatePost(PlayerEntity player, Parkourability parkourability, Playe } @Override - public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerEntity clientPlayer, Parkourability parkourability) { + public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerWrapper clientPlayer, Parkourability parkourability) { if (!(clientPlayer.isLocalPlayer() && Minecraft.getInstance().options.getCameraType().isFirstPerson() && ParCoolConfig.Client.Booleans.EnableCameraAnimationOfBackWallJump.get() diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/CatLeapAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/CatLeapAnimator.java index d9e98a0c..707cc6e0 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/CatLeapAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/CatLeapAnimator.java @@ -6,19 +6,20 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.Easing; import com.alrex.parcool.utilities.EasingFunctions; -import net.minecraft.entity.player.PlayerEntity; import static com.alrex.parcool.utilities.MathUtil.lerp; +import com.alrex.parcool.api.compatibility.PlayerWrapper; + public class CatLeapAnimator extends Animator { @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return !parkourability.get(CatLeap.class).isDoing() || getTick() > 20; } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { CatLeap catLeap = parkourability.get(CatLeap.class); float phase = (catLeap.getDoingTick() + transformer.getPartialTick()) / 20f; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/ChargeJumpAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/ChargeJumpAnimator.java index 9e6dafcc..98e8a9c2 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/ChargeJumpAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/ChargeJumpAnimator.java @@ -1,21 +1,21 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.ChargeJump; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.Easing; -import net.minecraft.entity.player.PlayerEntity; public class ChargeJumpAnimator extends Animator { @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return getTick() >= ChargeJump.JUMP_ANIMATION_TICK; } @Override - public boolean animatePre(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public boolean animatePre(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float animationPhase = Math.min(1f, (getTick() + transformer.getPartialTick()) / ChargeJump.JUMP_ANIMATION_TICK); float animFactor = new Easing(animationPhase) .linear(0f, 8f, 1f, 1) @@ -125,7 +125,7 @@ public boolean animatePre(PlayerEntity player, Parkourability parkourability, Pl } @Override - public boolean rotatePre(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public boolean rotatePre(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float animationPhase = Math.min(1f, (getTick() + rotator.getPartialTick()) / ChargeJump.JUMP_ANIMATION_TICK); float animFactor = new Easing(animationPhase) .linear(0f, 8f, 1f, 1) diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/ClimbUpAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/ClimbUpAnimator.java index b575f352..2e590dcf 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/ClimbUpAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/ClimbUpAnimator.java @@ -1,18 +1,18 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.EasingFunctions; import com.alrex.parcool.utilities.MathUtil; -import net.minecraft.entity.player.PlayerEntity; public class ClimbUpAnimator extends Animator { private static final int MaxTick = 10; @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return MaxTick <= getTick(); } @@ -33,7 +33,7 @@ private float armAngle(float phase) { } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float phase = (getTick() + rotator.getPartialTick()) / MaxTick; float factor = bodyAngleFactor(phase); @@ -44,7 +44,7 @@ public void rotatePost(PlayerEntity player, Parkourability parkourability, Playe } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float phase = (getTick() + transformer.getPartialTick()) / MaxTick; float angleArm = armAngle(phase); float bodyAngleFactor = bodyAngleFactor(phase); diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/ClingToCliffAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/ClingToCliffAnimator.java index 21bcb877..6239d512 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/ClingToCliffAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/ClingToCliffAnimator.java @@ -1,21 +1,21 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.ClingToCliff; import com.alrex.parcool.common.capability.Parkourability; -import net.minecraft.entity.player.PlayerEntity; public class ClingToCliffAnimator extends Animator { private final float Lean_Angle = 20; @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return !parkourability.get(ClingToCliff.class).isDoing(); } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { switch (parkourability.get(ClingToCliff.class).getFacingDirection()) { case ToWall: double zAngle = 10 + 20 * Math.sin(24 * parkourability.get(ClingToCliff.class).getArmSwingAmount()); @@ -59,7 +59,7 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { ClingToCliff cling = parkourability.get(ClingToCliff.class); switch (cling.getFacingDirection()) { case RightAgainstWall: diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/CrawlAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/CrawlAnimator.java index 644e9281..2581141e 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/CrawlAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/CrawlAnimator.java @@ -1,19 +1,19 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.Crawl; import com.alrex.parcool.common.capability.Parkourability; -import net.minecraft.entity.player.PlayerEntity; public class CrawlAnimator extends Animator { @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return !parkourability.get(Crawl.class).isDoing(); } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float factor = (float) Math.sin(transformer.getLimbSwing() / 10 * Math.PI); float leftZFactor = (float) Math.cos(transformer.getLimbSwing() / 10 * Math.PI); float rightZFactor = -leftZFactor; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/DiveAnimationHostAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/DiveAnimationHostAnimator.java index 3322f93b..e1c79e99 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/DiveAnimationHostAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/DiveAnimationHostAnimator.java @@ -1,5 +1,6 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -10,7 +11,6 @@ import com.alrex.parcool.utilities.Easing; import com.alrex.parcool.utilities.EasingFunctions; import com.alrex.parcool.utilities.MathUtil; -import net.minecraft.entity.player.PlayerEntity; import javax.annotation.Nullable; @@ -27,7 +27,7 @@ public DiveAnimationHostAnimator(double ySpeed, boolean fromInAir) { final static int MaxTransitionTick = 6; @Override - public void tick(PlayerEntity player) { + public void tick(PlayerWrapper player) { super.tick(player); diveAnimator.tick(player); if (skyDiveAnimator != null) skyDiveAnimator.tick(player); @@ -41,7 +41,7 @@ public void tick(PlayerEntity player) { } @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return !parkourability.get(Dive.class).isDoing(); } @@ -56,7 +56,7 @@ void checkTransition(Parkourability parkourability) { } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { if (fromInAir && getTick() < MaxTransitionStartedInAirTick) { // transition when started in air float phase = (getTick() + transformer.getPartialTick()) / MaxTransitionStartedInAirTick; diveAnimator.animatePost( @@ -100,7 +100,7 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { if (fromInAir && getTick() < MaxTransitionStartedInAirTick) { // transition when started in air float factor = new Easing((getTick() + rotator.getPartialTick()) / MaxTransitionStartedInAirTick) .squareOut(0, 1, 0, 1) @@ -159,12 +159,12 @@ public SkyDiveAnimator(float startPitchAngleDegree) { } @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return false; } @Override - public void tick(PlayerEntity player) { + public void tick(PlayerWrapper player) { super.tick(player); forwardAngleCountOld = forwardAngleCount; rightAngleCountOld = rightAngleCount; @@ -197,11 +197,11 @@ public void tick(PlayerEntity player) { } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { animatePost(player, parkourability, transformer, 1); } - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer, float factor) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer, float factor) { float forwardAngleFactor = getForwardAngleFactor(transformer.getPartialTick()); float rightAngleFactor = getRightAngleFactor(transformer.getPartialTick()); transformer. @@ -251,7 +251,7 @@ else if (rightAngleCount < 0) } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float forwardAngleFactor = getForwardAngleFactor(rotator.getPartialTick()); float rightAngleFactor = getRightAngleFactor(rotator.getPartialTick()); float basePitchAngle; @@ -288,16 +288,16 @@ private float getFactor(double yMovement) { } @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return false; } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { animatePost(player, parkourability, transformer, 1); } - void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer, float factor) { + void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer, float factor) { double ySpeed = parkourability.get(Dive.class).getPlayerYSpeed(transformer.getPartialTick()); float bodyFactor = getFactor(ySpeed); transformer @@ -311,11 +311,11 @@ void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModel } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { rotate(player, parkourability, rotator, 1, 0); } - public void rotate(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator, float factor, float transitionBaseAngle) { + public void rotate(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator, float factor, float transitionBaseAngle) { double ySpeed = parkourability.get(Dive.class).getPlayerYSpeed(rotator.getPartialTick()); float angleFactor = getFactor(ySpeed); pitchAngle = 180 * angleFactor; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/DiveIntoWaterAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/DiveIntoWaterAnimator.java index 1d04fc3f..966d2e45 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/DiveIntoWaterAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/DiveIntoWaterAnimator.java @@ -1,11 +1,11 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.Easing; -import net.minecraft.entity.player.PlayerEntity; public class DiveIntoWaterAnimator extends Animator { private static final int MAX_ANIMATION_TICK = 9; @@ -16,12 +16,12 @@ public DiveIntoWaterAnimator(boolean fromSkyDive) { } @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return getTick() >= MAX_ANIMATION_TICK; } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float phase = (getTick() + transformer.getPartialTick()) / MAX_ANIMATION_TICK; if (phase > 1) return; float animationFactor = new Easing(phase) @@ -51,7 +51,7 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float phase = (getTick() + rotator.getPartialTick()) / MAX_ANIMATION_TICK; if (phase > 1) return; float pitchFactor = new Easing(phase) diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/DodgeAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/DodgeAnimator.java index f3c8656f..7c51b4bb 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/DodgeAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/DodgeAnimator.java @@ -1,5 +1,6 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -8,13 +9,12 @@ import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.Easing; import net.minecraft.client.Minecraft; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.client.event.EntityViewRenderEvent; import net.minecraftforge.event.TickEvent; public class DodgeAnimator extends Animator { @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return getTick() >= Dodge.MAX_TICK; } @@ -25,7 +25,7 @@ public DodgeAnimator(Dodge.DodgeDirection dodgeDirection) { } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float phase = (getTick() + transformer.getPartialTick()) / Dodge.MAX_TICK; if (phase > 1) { return; @@ -227,7 +227,7 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float phase = (getTick() + rotator.getPartialTick()) / Dodge.MAX_TICK; if (phase > 1) { return; @@ -299,7 +299,7 @@ public void rotatePost(PlayerEntity player, Parkourability parkourability, Playe } @Override - public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerEntity clientPlayer, Parkourability parkourability) { + public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerWrapper clientPlayer, Parkourability parkourability) { if (!(clientPlayer.isLocalPlayer() && Minecraft.getInstance().options.getCameraType().isFirstPerson() && ParCoolConfig.Client.Booleans.EnableCameraAnimationOfDodge.get() @@ -335,7 +335,7 @@ public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerEntity } @Override - public void onRenderTick(TickEvent.RenderTickEvent event, PlayerEntity player, Parkourability parkourability) { + public void onRenderTick(TickEvent.RenderTickEvent event, PlayerWrapper player, Parkourability parkourability) { switch (direction) { case Right: { player.setYBodyRot(player.getYHeadRot() - 5); diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/ExaggeratedSideDodgeAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/ExaggeratedSideDodgeAnimator.java index d8fc1f6b..74c3de6f 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/ExaggeratedSideDodgeAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/ExaggeratedSideDodgeAnimator.java @@ -1,19 +1,19 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.Dodge; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.Easing; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.event.TickEvent; public class ExaggeratedSideDodgeAnimator extends Animator { public static final int Dodge_Max_Tick = 14; @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return getTick() >= Dodge_Max_Tick; } @@ -24,7 +24,7 @@ public ExaggeratedSideDodgeAnimator(Dodge.DodgeDirection dodgeDirection) { } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float phase = (getTick() + transformer.getPartialTick()) / Dodge_Max_Tick; if (phase > 1) { return; @@ -103,11 +103,9 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float phase = (getTick() + rotator.getPartialTick()) / Dodge_Max_Tick; - if (phase > 1) { - return; - } + if (phase > 1) return; switch (direction) { case Left: { float bodyPitchFactor = new Easing(phase) @@ -147,7 +145,7 @@ public void rotatePost(PlayerEntity player, Parkourability parkourability, Playe } @Override - public void onRenderTick(TickEvent.RenderTickEvent event, PlayerEntity player, Parkourability parkourability) { + public void onRenderTick(TickEvent.RenderTickEvent event, PlayerWrapper player, Parkourability parkourability) { player.setYBodyRot(player.getYHeadRot()); } } diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/FastRunningAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/FastRunningAnimator.java index 833ae9d0..15b4a530 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/FastRunningAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/FastRunningAnimator.java @@ -1,5 +1,6 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -8,17 +9,14 @@ import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.BipedModelUtil; import com.alrex.parcool.utilities.Easing; -import com.alrex.parcool.utilities.MathUtil; -import com.alrex.parcool.utilities.VectorUtil; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.entity.model.BipedModel; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.HandSide; import net.minecraft.util.math.vector.Vector3d; public class FastRunningAnimator extends Animator { @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return !parkourability.get(FastRun.class).isDoing(); } @@ -30,7 +28,7 @@ private float bodyAngleFactor(float phase) { private float limbSwing = 0; @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { limbSwing = transformer.getLimbSwing(); float phase = (getTick() + transformer.getPartialTick()) / 10; if (phase > 1) phase = 1; @@ -128,7 +126,7 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float tick = getTick() + rotator.getPartialTick(); float phase = tick / 10; if (phase > 1) phase = 1; @@ -144,7 +142,7 @@ public void rotatePost(PlayerEntity player, Parkourability parkourability, Playe .end(); } else { Vector3d lookAngle = player.getLookAngle(); - Vector3d bodyAngle = VectorUtil.fromYawDegree(MathUtil.lerp(player.yBodyRotO, player.yBodyRot, rotator.getPartialTick())); + Vector3d bodyAngle = player.getRotatedBodyAngle(rotator); Vector3d differenceVec = new Vector3d( lookAngle.x() * bodyAngle.x() + lookAngle.z() * bodyAngle.z(), 0, diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/FastSwimAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/FastSwimAnimator.java index b6255839..c5bae503 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/FastSwimAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/FastSwimAnimator.java @@ -1,27 +1,25 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.FastSwim; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.BipedModelUtil; -import com.alrex.parcool.utilities.MathUtil; -import com.alrex.parcool.utilities.VectorUtil; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.entity.model.BipedModel; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.HandSide; import net.minecraft.util.math.vector.Vector3d; public class FastSwimAnimator extends Animator { @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return !parkourability.get(FastSwim.class).isDoing(); } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float animationFactor = (getTick() + transformer.getPartialTick()) / 10; if (animationFactor > 1) animationFactor = 1; float tick = getTick() + transformer.getPartialTick(); @@ -84,13 +82,13 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { if (player.isLocalPlayer() && Minecraft.getInstance().screen != null) { return; } float tick = getTick() + rotator.getPartialTick(); Vector3d lookAngle = player.getLookAngle(); - Vector3d bodyAngle = VectorUtil.fromYawDegree(MathUtil.lerp(player.yBodyRotO, player.yBodyRot, rotator.getPartialTick())); + Vector3d bodyAngle = player.getRotatedBodyAngle(rotator); Vector3d differenceVec = new Vector3d( lookAngle.x() * bodyAngle.x() + lookAngle.z() * bodyAngle.z(), 0, diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/FlippingAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/FlippingAnimator.java index aa9f39f7..54129f2e 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/FlippingAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/FlippingAnimator.java @@ -1,5 +1,6 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -9,7 +10,6 @@ import com.alrex.parcool.utilities.EasingFunctions; import com.alrex.parcool.utilities.MathUtil; import net.minecraft.client.Minecraft; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.client.event.EntityViewRenderEvent; public class FlippingAnimator extends Animator { @@ -24,7 +24,7 @@ private int getMaxAnimationTick() { } @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return !parkourability.get(Flipping.class).isDoing() || getTick() >= getMaxAnimationTick(); } @@ -75,7 +75,7 @@ private float legAngleFactorFront(float phase) { } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float phase = (getTick() + transformer.getPartialTick()) / getMaxAnimationTick(); if (direction == Flipping.Direction.Front) { @@ -142,7 +142,7 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float phase = (getTick() + rotator.getPartialTick()) / getMaxAnimationTick(); float factor = angleFactor(phase); @@ -159,7 +159,7 @@ public void rotatePost(PlayerEntity player, Parkourability parkourability, Playe } @Override - public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerEntity clientPlayer, Parkourability parkourability) { + public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerWrapper clientPlayer, Parkourability parkourability) { if (!clientPlayer.isLocalPlayer() || !Minecraft.getInstance().options.getCameraType().isFirstPerson() || !ParCoolConfig.Client.Booleans.EnableCameraAnimationOfFlipping.get() diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/HangAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/HangAnimator.java index e0817b97..0b0da41d 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/HangAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/HangAnimator.java @@ -1,5 +1,6 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -7,16 +8,15 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.client.Minecraft; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.client.event.EntityViewRenderEvent; public class HangAnimator extends Animator { @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return !parkourability.get(HangDown.class).isDoing(); } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { HangDown hangDown = parkourability.get(HangDown.class); HangDown.BarAxis axis = hangDown.getHangingBarAxis(); if (axis == null) return; @@ -63,7 +63,7 @@ private float getRotateAngle(HangDown hangDown, double partialTick) { } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { HangDown hangDown = parkourability.get(HangDown.class); rotator.startBasedTop() .rotatePitchFrontward(getRotateAngle(hangDown, rotator.getPartialTick())) @@ -71,7 +71,7 @@ public void rotatePost(PlayerEntity player, Parkourability parkourability, Playe } @Override - public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerEntity clientPlayer, Parkourability parkourability) { + public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerWrapper clientPlayer, Parkourability parkourability) { if (!clientPlayer.isLocalPlayer() || !Minecraft.getInstance().options.getCameraType().isFirstPerson() || !ParCoolConfig.Client.Booleans.EnableCameraAnimationOfHangDown.get() diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/HideInBlockAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/HideInBlockAnimator.java index ebc10d30..a3fb2b01 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/HideInBlockAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/HideInBlockAnimator.java @@ -1,5 +1,6 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -8,7 +9,6 @@ import com.alrex.parcool.utilities.Easing; import com.alrex.parcool.utilities.MathUtil; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.MathHelper; import net.minecraft.util.math.vector.Vector3d; @@ -27,12 +27,12 @@ public HideInBlockAnimator(boolean standing) { this.standing = standing; } @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return !parkourability.get(HideInBlock.class).isDoing(); } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float phase = (getTick() + transformer.getPartialTick()) / 5f; if (phase > 1f) phase = 1f; float factor = Easing.with(phase).sinInOut(0f, 1f, 0, 1f).get(); @@ -56,14 +56,14 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public boolean rotatePre(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public boolean rotatePre(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float phase = (getTick() + rotator.getPartialTick()) / 5f; if (phase > 1f) phase = 1f; float factor = Easing.with(phase).sinInOut(0f, 1f, 0, 1f).get(); Vector3d lookVec = parkourability.get(HideInBlock.class).getLookDirection(); if (lookVec == null) return false; if (standing) { - float playerYRot = 180f + MathHelper.lerp(rotator.getPartialTick(), player.yRotO, player.yRot); + float playerYRot = player.getRotatedYRot(rotator); float yRot = (float) VectorUtil.toYawDegree(lookVec); rotator.rotateYawRightward(playerYRot + MathUtil.normalizeDegree((180f + yRot) - playerYRot) * factor); return true; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/HorizontalWallRunAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/HorizontalWallRunAnimator.java index a041692b..035983da 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/HorizontalWallRunAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/HorizontalWallRunAnimator.java @@ -1,5 +1,6 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -8,7 +9,6 @@ import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.MathUtil; import net.minecraft.client.Minecraft; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.MathHelper; import net.minecraftforge.client.event.EntityViewRenderEvent; @@ -20,13 +20,13 @@ public HorizontalWallRunAnimator(boolean wallIsRightSide) { } @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return !parkourability.get(HorizontalWallRun.class).isDoing(); } private float limbSwing = 0; @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { limbSwing = transformer.getLimbSwing(); float factor = getFactor(getTick() + transformer.getPartialTick()); float angle = factor * 15f * (wallIsRightSide ? -1f : 1f); @@ -80,7 +80,7 @@ private float getFactor(float tick) { } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float factor = getFactor(getTick() + rotator.getPartialTick()); float sign = wallIsRightSide ? -1 : 1; float angle = factor * 30f * sign; @@ -94,7 +94,7 @@ public void rotatePost(PlayerEntity player, Parkourability parkourability, Playe } @Override - public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerEntity clientPlayer, Parkourability parkourability) { + public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerWrapper clientPlayer, Parkourability parkourability) { if (!Minecraft.getInstance().options.getCameraType().isFirstPerson() || !ParCoolConfig.Client.Booleans.EnableCameraAnimationOfHWallRun.get() ) diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/JumpChargingAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/JumpChargingAnimator.java index d843beea..20e66177 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/JumpChargingAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/JumpChargingAnimator.java @@ -1,22 +1,22 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.ChargeJump; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.Easing; -import net.minecraft.entity.player.PlayerEntity; public class JumpChargingAnimator extends Animator { @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { ChargeJump c = parkourability.get(ChargeJump.class); return !c.isCharging(); } @Override - public boolean animatePre(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public boolean animatePre(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float transitionPhase = Math.min(1f, (parkourability.get(ChargeJump.class).getChargingTick() + transformer.getPartialTick()) / ChargeJump.JUMP_MAX_CHARGE_TICK); float animFactor = new Easing(transitionPhase) .sinInOut(0, 1, 0, 1) @@ -52,7 +52,7 @@ public boolean animatePre(PlayerEntity player, Parkourability parkourability, Pl } @Override - public boolean rotatePre(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public boolean rotatePre(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float transitionPhase = Math.min(1f, (parkourability.get(ChargeJump.class).getChargingTick() + rotator.getPartialTick()) / ChargeJump.JUMP_MAX_CHARGE_TICK); float animFactor = new Easing(transitionPhase) .sinInOut(0, 1, 0, 1) diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/JumpFromBarAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/JumpFromBarAnimator.java index f41f29c9..d9ef9fac 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/JumpFromBarAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/JumpFromBarAnimator.java @@ -1,18 +1,18 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.EasingFunctions; import com.alrex.parcool.utilities.MathUtil; -import net.minecraft.entity.player.PlayerEntity; public class JumpFromBarAnimator extends Animator { private final int MAX_TICK = 8; @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return getTick() >= MAX_TICK; } @@ -28,7 +28,7 @@ private static float getFactor(float phase) { } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float tick = getTick() + transformer.getPartialTick(); float phase = tick / MAX_TICK; float factor = getFactor(phase); @@ -59,7 +59,7 @@ private float getBodyAngleFactor(float phase) { } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float tick = getTick() + rotator.getPartialTick(); float phase = tick / MAX_TICK; float factor = getBodyAngleFactor(phase); diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/KongVaultAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/KongVaultAnimator.java index 8a257bb8..f3a84b99 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/KongVaultAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/KongVaultAnimator.java @@ -1,5 +1,6 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -9,10 +10,7 @@ import com.alrex.parcool.utilities.Easing; import com.alrex.parcool.utilities.EasingFunctions; import com.alrex.parcool.utilities.MathUtil; -import com.alrex.parcool.utilities.VectorUtil; import net.minecraft.client.Minecraft; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.client.event.EntityViewRenderEvent; import static java.lang.Math.toRadians; @@ -37,24 +35,19 @@ float getArmFactor(float phase) { private float yRotDifferenceOld = 0; @Override - public void tick(PlayerEntity player) { + public void tick(PlayerWrapper player) { super.tick(player); yRotDifferenceOld = yRotDifference; - Vector3d currentAngle = VectorUtil.fromYawDegree(player.yBodyRot); - Vector3d oldAngle = VectorUtil.fromYawDegree(player.yBodyRotO); - yRotDifference = (float) Math.atan( - (oldAngle.x() * currentAngle.z() - currentAngle.x() * oldAngle.z()) - / (currentAngle.x() * oldAngle.x() + currentAngle.z() * oldAngle.z()) - ); + yRotDifference = (float) player.getUpdatedYRotDifference(); } @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return getTick() >= Vault.MAX_TICK; } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float phase = (getTick() + transformer.getPartialTick()) / Vault.MAX_TICK; float armFactor = getArmFactor(phase); float factor = getFactor(phase); @@ -105,7 +98,7 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float phase = (getTick() + rotator.getPartialTick()) / Vault.MAX_TICK; float factor = getFactor(phase); float yFactor = new Easing(phase) @@ -120,7 +113,7 @@ public void rotatePost(PlayerEntity player, Parkourability parkourability, Playe } @Override - public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerEntity clientPlayer, Parkourability parkourability) { + public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerWrapper clientPlayer, Parkourability parkourability) { if (!Minecraft.getInstance().options.getCameraType().isFirstPerson() || !ParCoolConfig.Client.Booleans.EnableCameraAnimationOfVault.get() ) return; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/RideZiplineAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/RideZiplineAnimator.java index 5490619c..3eba12fb 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/RideZiplineAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/RideZiplineAnimator.java @@ -1,16 +1,15 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.RideZipline; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.MathHelper; import net.minecraft.util.math.vector.Vector3d; import net.minecraft.util.math.vector.Vector3f; -import net.minecraftforge.common.ForgeMod; import net.minecraftforge.event.TickEvent; public class RideZiplineAnimator extends Animator { @@ -18,7 +17,7 @@ public class RideZiplineAnimator extends Animator { private double currentAngleRadian = 0; @Override - public void tick(PlayerEntity player) { + public void tick(PlayerWrapper player) { super.tick(player); Parkourability parkourability = Parkourability.get(player); @@ -28,7 +27,7 @@ public void tick(PlayerEntity player) { oldAngleRadian = currentAngleRadian; double acceleration = action.getAcceleration(); double slope = action.getSlope(); - double gravity = player.getAttributeValue(ForgeMod.ENTITY_GRAVITY.get()); + double gravity = player.getGravity(); double invSqrt = MathHelper.fastInvSqrt(slope * slope + 1); double xz = -acceleration * invSqrt; double y = gravity + acceleration * slope * invSqrt; @@ -36,12 +35,12 @@ public void tick(PlayerEntity player) { } @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return !parkourability.get(RideZipline.class).isDoing(); } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { Vector3d offset = parkourability.get(RideZipline.class).getEndOffsetFromStart(); if (offset == null) return; double angleDifference = VectorUtil.toYawRadian(player.getLookAngle()) - VectorUtil.toYawRadian(new Vector3d(offset.x(), 0, offset.z())); @@ -60,13 +59,12 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public void onRenderTick(TickEvent.RenderTickEvent event, PlayerEntity player, Parkourability parkourability) { - player.yBodyRot = player.yRot; - player.yBodyRotO = player.yRotO; + public void onRenderTick(TickEvent.RenderTickEvent event, PlayerWrapper player, Parkourability parkourability) { + player.updateBodyRot(); } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { Vector3d offset = parkourability.get(RideZipline.class).getEndOffsetFromStart(); if (offset == null) return; Vector3d rotationAxis = new Vector3d(0, 0, 1) diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/RollAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/RollAnimator.java index 1a116446..a131e9a0 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/RollAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/RollAnimator.java @@ -1,5 +1,6 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -9,7 +10,6 @@ import com.alrex.parcool.utilities.Easing; import com.alrex.parcool.utilities.MathUtil; import net.minecraft.client.Minecraft; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.client.event.EntityViewRenderEvent; import net.minecraftforge.event.TickEvent; @@ -25,12 +25,12 @@ private static float calculateMovementFactor(float progress) { } @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return !parkourability.get(Roll.class).isDoing(); } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { switch (direction) { case Front: case Back: { @@ -45,7 +45,7 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } } - void animatePostFrontBack(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + void animatePostFrontBack(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { Roll roll = parkourability.get(Roll.class); float phase = (getTick() + transformer.getPartialTick()) / roll.getRollMaxTick(); if (phase > 1) return; @@ -71,7 +71,7 @@ void animatePostFrontBack(PlayerEntity player, Parkourability parkourability, Pl .end(); } - void animatePostLeftRight(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + void animatePostLeftRight(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { Roll roll = parkourability.get(Roll.class); float phase = (getTick() + transformer.getPartialTick()) / roll.getRollMaxTick(); if (phase > 1) { @@ -196,7 +196,7 @@ void animatePostLeftRight(PlayerEntity player, Parkourability parkourability, Pl } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { switch (direction) { case Front: case Back: { @@ -211,7 +211,7 @@ public void rotatePost(PlayerEntity player, Parkourability parkourability, Playe } } - private void rotateFrontBack(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + private void rotateFrontBack(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { Roll roll = parkourability.get(Roll.class); float phase = (getTick() + rotator.getPartialTick()) / roll.getRollMaxTick(); if (phase > 1) return; @@ -237,7 +237,7 @@ private void rotateFrontBack(PlayerEntity player, Parkourability parkourability, .end(); } - private void rotateLeftRight(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + private void rotateLeftRight(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float phase = (getTick() + rotator.getPartialTick()) / parkourability.get(Roll.class).getRollMaxTick(); if (phase > 1) { return; @@ -284,7 +284,7 @@ private void rotateLeftRight(PlayerEntity player, Parkourability parkourability, } @Override - public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerEntity clientPlayer, Parkourability parkourability) { + public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerWrapper clientPlayer, Parkourability parkourability) { switch (direction) { case Front: case Back: { @@ -299,7 +299,7 @@ public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerEntity } } - void onCameraSetUpFrontBack(EntityViewRenderEvent.CameraSetup event, PlayerEntity clientPlayer, Parkourability parkourability) { + void onCameraSetUpFrontBack(EntityViewRenderEvent.CameraSetup event, PlayerWrapper clientPlayer, Parkourability parkourability) { Roll roll = parkourability.get(Roll.class); float sign = direction == Roll.Direction.Front ? 1 : -1; if (roll.isDoing() && @@ -312,7 +312,7 @@ void onCameraSetUpFrontBack(EntityViewRenderEvent.CameraSetup event, PlayerEntit } } - void onCameraSetUpLeftRight(EntityViewRenderEvent.CameraSetup event, PlayerEntity clientPlayer, Parkourability parkourability) { + void onCameraSetUpLeftRight(EntityViewRenderEvent.CameraSetup event, PlayerWrapper clientPlayer, Parkourability parkourability) { float phase = (float) ((getTick() + event.getRenderPartialTicks()) / parkourability.get(Roll.class).getRollMaxTick()); if (phase > 1) { return; @@ -333,7 +333,7 @@ void onCameraSetUpLeftRight(EntityViewRenderEvent.CameraSetup event, PlayerEntit } @Override - public void onRenderTick(TickEvent.RenderTickEvent event, PlayerEntity player, Parkourability parkourability) { + public void onRenderTick(TickEvent.RenderTickEvent event, PlayerWrapper player, Parkourability parkourability) { switch (direction) { case Right: { player.setYBodyRot(player.getYHeadRot() - 5); diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/SlidingAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/SlidingAnimator.java index d3b89d9b..71cf43dc 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/SlidingAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/SlidingAnimator.java @@ -1,5 +1,6 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -7,18 +8,17 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.Easing; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.vector.Vector3d; public class SlidingAnimator extends Animator { private static final int MAX_TRANSITION_TICK = 5; @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return !parkourability.get(Slide.class).isDoing(); } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float animFactor = (getTick() + transformer.getPartialTick()) / MAX_TRANSITION_TICK; if (animFactor > 1) animFactor = 1; animFactor = new Easing(animFactor) @@ -50,7 +50,7 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public boolean rotatePre(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public boolean rotatePre(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { Vector3d vec = parkourability.get(Slide.class).getSlidingVector(); if (vec == null) return false; float animFactor = (getTick() + rotator.getPartialTick()) / MAX_TRANSITION_TICK; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/SpeedVaultAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/SpeedVaultAnimator.java index 48b685d4..93fcddfa 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/SpeedVaultAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/SpeedVaultAnimator.java @@ -9,15 +9,16 @@ import com.alrex.parcool.utilities.Easing; import com.alrex.parcool.utilities.EasingFunctions; import net.minecraft.client.Minecraft; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.client.event.EntityViewRenderEvent; import static com.alrex.parcool.utilities.MathUtil.lerp; +import com.alrex.parcool.api.compatibility.PlayerWrapper; + public class SpeedVaultAnimator extends Animator { @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return getTick() >= Vault.MAX_TICK; } @@ -31,7 +32,7 @@ private float getFactor(float tick) { } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float phase = (getTick() + rotator.getPartialTick()) / Vault.MAX_TICK; float factor = getFactor(getTick() + rotator.getPartialTick()); float forwardFactor = (float) Math.sin(phase * 2 * Math.PI) + 0.5f; @@ -48,7 +49,7 @@ public void rotatePost(PlayerEntity player, Parkourability parkourability, Playe } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float phase = (getTick() + transformer.getPartialTick()) / Vault.MAX_TICK; float animFactor = new Easing(phase) .sinInOut(0, 0.25f, 0, 1) @@ -107,7 +108,7 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerEntity clientPlayer, Parkourability parkourability) { + public void onCameraSetUp(EntityViewRenderEvent.CameraSetup event, PlayerWrapper clientPlayer, Parkourability parkourability) { if (!Minecraft.getInstance().options.getCameraType().isFirstPerson() || !ParCoolConfig.Client.Booleans.EnableCameraAnimationOfVault.get()) return; float factor = getFactor((float) (getTick() + event.getRenderPartialTicks())); diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/TapAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/TapAnimator.java index 09334a4d..d8167c5f 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/TapAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/TapAnimator.java @@ -1,16 +1,16 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.Tap; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.Easing; -import net.minecraft.entity.player.PlayerEntity; public class TapAnimator extends Animator { @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return getTick() >= parkourability.get(Tap.class).getMaxTappingTick(); } @@ -22,7 +22,7 @@ public float getAngleFactor(float phase) { } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float phase = (getTick() + transformer.getPartialTick()) / parkourability.get(Tap.class).getMaxTappingTick(); if (phase > 1) phase = 1; float factor = getAngleFactor(phase); @@ -54,7 +54,7 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float phase = (getTick() + rotator.getPartialTick()) / parkourability.get(Tap.class).getMaxTappingTick(); if (phase > 1) phase = 1; float factor = getAngleFactor(phase); diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/VerticalWallRunAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/VerticalWallRunAnimator.java index 67f290cb..d187fa01 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/VerticalWallRunAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/VerticalWallRunAnimator.java @@ -1,23 +1,23 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.Easing; -import net.minecraft.entity.player.PlayerEntity; public class VerticalWallRunAnimator extends Animator { static final int MAX_ANIMATION_TICK = 10; static final int ROLL_ANGLE = 15; @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return getTick() >= MAX_ANIMATION_TICK; } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float phase = (getTick() + transformer.getPartialTick()) / MAX_ANIMATION_TICK; if (phase > 1) { return; @@ -74,7 +74,7 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float phase = (getTick() + rotator.getPartialTick()) / MAX_ANIMATION_TICK; if (phase > 1) { return; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/WallJumpAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/WallJumpAnimator.java index 778fb744..3876d241 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/WallJumpAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/WallJumpAnimator.java @@ -1,11 +1,11 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.Easing; -import net.minecraft.entity.player.PlayerEntity; import static java.lang.Math.toRadians; @@ -30,12 +30,12 @@ float getFadeFactor(float phase) { } @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return getTick() >= maxTick; } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { float phase = (getTick() + transformer.getPartialTick()) / maxTick; float factor = getFactor(phase); float fadeFactor = getFadeFactor(phase); @@ -83,7 +83,7 @@ public void animatePost(PlayerEntity player, Parkourability parkourability, Play } @Override - public void rotatePost(PlayerEntity player, Parkourability parkourability, PlayerModelRotator rotator) { + public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { float phase = (getTick() + rotator.getPartialTick()) / maxTick; float factor = getFactor(phase); rotator diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/WallSlideAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/WallSlideAnimator.java index ffccc325..f6c192f0 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/WallSlideAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/WallSlideAnimator.java @@ -1,24 +1,24 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.WallSlide; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.vector.Vector3d; public class WallSlideAnimator extends Animator { @Override - public boolean shouldRemoved(PlayerEntity player, Parkourability parkourability) { + public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability) { return !parkourability.get(WallSlide.class).isDoing(); } @Override - public void animatePost(PlayerEntity player, Parkourability parkourability, PlayerModelTransformer transformer) { + public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { Vector3d wall = parkourability.get(WallSlide.class).getLeanedWallDirection(); if (wall == null) return; - Vector3d bodyVec = VectorUtil.fromYawDegree(player.yBodyRot); + Vector3d bodyVec = player.getVectorYBodyRot(); Vector3d vec = new Vector3d(bodyVec.x(), 0, bodyVec.z()).normalize(); Vector3d dividedVec = diff --git a/src/main/java/com/alrex/parcool/client/gui/SettingActionLimitationScreen.java b/src/main/java/com/alrex/parcool/client/gui/SettingActionLimitationScreen.java index a1857b44..91dfaef1 100644 --- a/src/main/java/com/alrex/parcool/client/gui/SettingActionLimitationScreen.java +++ b/src/main/java/com/alrex/parcool/client/gui/SettingActionLimitationScreen.java @@ -1,5 +1,6 @@ package com.alrex.parcool.client.gui; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.ActionList; import com.alrex.parcool.common.capability.Parkourability; @@ -8,8 +9,6 @@ import com.alrex.parcool.common.network.SyncClientInformationMessage; import com.alrex.parcool.config.ParCoolConfig; import com.mojang.blaze3d.matrix.MatrixStack; -import net.minecraft.client.Minecraft; -import net.minecraft.client.entity.player.ClientPlayerEntity; import net.minecraft.client.gui.widget.button.CheckboxButton; import net.minecraft.util.text.ITextComponent; import net.minecraft.util.text.StringTextComponent; @@ -98,7 +97,7 @@ protected void save() { for (int i = 0; i < actionList.length; i++) { actionList[i].setter.accept(actionButtons[i].selected()); } - ClientPlayerEntity player = Minecraft.getInstance().player; + ClientPlayerWrapper player = ClientPlayerWrapper.get(); if (player == null) return; Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; diff --git a/src/main/java/com/alrex/parcool/client/gui/SettingBooleanConfigScreen.java b/src/main/java/com/alrex/parcool/client/gui/SettingBooleanConfigScreen.java index 74a91bcb..6975d106 100644 --- a/src/main/java/com/alrex/parcool/client/gui/SettingBooleanConfigScreen.java +++ b/src/main/java/com/alrex/parcool/client/gui/SettingBooleanConfigScreen.java @@ -1,13 +1,12 @@ package com.alrex.parcool.client.gui; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ActionInfo; import com.alrex.parcool.common.info.ClientSetting; import com.alrex.parcool.common.network.SyncClientInformationMessage; import com.alrex.parcool.config.ParCoolConfig; import com.mojang.blaze3d.matrix.MatrixStack; -import net.minecraft.client.Minecraft; -import net.minecraft.client.entity.player.ClientPlayerEntity; import net.minecraft.client.gui.widget.button.CheckboxButton; import net.minecraft.util.text.ITextComponent; import net.minecraft.util.text.StringTextComponent; @@ -81,7 +80,7 @@ protected void save() { for (int i = 0; i < booleans.length; i++) { booleans[i].set(configButtons[i].selected()); } - ClientPlayerEntity player = Minecraft.getInstance().player; + ClientPlayerWrapper player = ClientPlayerWrapper.get(); if (player == null) return; Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; diff --git a/src/main/java/com/alrex/parcool/client/gui/SettingEnumConfigScreen.java b/src/main/java/com/alrex/parcool/client/gui/SettingEnumConfigScreen.java index 5a5534db..ca912126 100644 --- a/src/main/java/com/alrex/parcool/client/gui/SettingEnumConfigScreen.java +++ b/src/main/java/com/alrex/parcool/client/gui/SettingEnumConfigScreen.java @@ -1,13 +1,12 @@ package com.alrex.parcool.client.gui; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ActionInfo; import com.alrex.parcool.common.info.ClientSetting; import com.alrex.parcool.common.network.SyncClientInformationMessage; import com.alrex.parcool.config.ParCoolConfig; import com.mojang.blaze3d.matrix.MatrixStack; -import net.minecraft.client.Minecraft; -import net.minecraft.client.entity.player.ClientPlayerEntity; import net.minecraft.client.gui.widget.button.Button; import net.minecraft.util.text.ITextComponent; import net.minecraft.util.text.StringTextComponent; @@ -89,7 +88,7 @@ public void onClose() { @Override protected void save() { - ClientPlayerEntity player = Minecraft.getInstance().player; + ClientPlayerWrapper player = ClientPlayerWrapper.get(); if (player == null) return; Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; diff --git a/src/main/java/com/alrex/parcool/client/hud/impl/LightStaminaHUD.java b/src/main/java/com/alrex/parcool/client/hud/impl/LightStaminaHUD.java index 84872700..9396d03c 100644 --- a/src/main/java/com/alrex/parcool/client/hud/impl/LightStaminaHUD.java +++ b/src/main/java/com/alrex/parcool/client/hud/impl/LightStaminaHUD.java @@ -1,6 +1,7 @@ package com.alrex.parcool.client.hud.impl; import com.alrex.parcool.api.Effects; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; @@ -8,7 +9,6 @@ import com.alrex.parcool.utilities.MathUtil; import com.mojang.blaze3d.matrix.MatrixStack; import net.minecraft.client.Minecraft; -import net.minecraft.client.entity.player.ClientPlayerEntity; import net.minecraft.client.gui.AbstractGui; import net.minecraftforge.client.event.RenderGameOverlayEvent; import net.minecraftforge.client.gui.ForgeIngameGui; @@ -27,12 +27,12 @@ public class LightStaminaHUD extends AbstractGui { private float oldStatusValue = 0f; private boolean showStatus = false; - public void onTick(TickEvent.ClientTickEvent event, ClientPlayerEntity player) { + public void onTick(TickEvent.ClientTickEvent event, ClientPlayerWrapper player) { IStamina stamina = IStamina.get(player); Parkourability parkourability = Parkourability.get(player); if (stamina == null || parkourability == null) return; changingSign = (int) Math.signum(stamina.get() - stamina.getOldValue()); - final long gameTime = player.level.getGameTime(); + final long gameTime = player.getGameTime(); if (changingSign != lastChangingSign) { lastChangingSign = changingSign; changingTimeTick = 0; @@ -72,7 +72,7 @@ public void onTick(TickEvent.ClientTickEvent event, ClientPlayerEntity player) { } public void render(RenderGameOverlayEvent.Post event, MatrixStack stack) { - ClientPlayerEntity player = Minecraft.getInstance().player; + ClientPlayerWrapper player = ClientPlayerWrapper.get(); if (player == null || player.isCreative()) return; IStamina stamina = IStamina.get(player); @@ -83,7 +83,7 @@ public void render(RenderGameOverlayEvent.Post event, MatrixStack stack) { final boolean exhausted = stamina.isExhausted(); if (!showStatus) { - long gameTime = player.level.getGameTime(); + long gameTime = player.getGameTime(); if (gameTime - lastStaminaChangedTick > 40) return; } float staminaScale = (float) stamina.get() / stamina.getActualMaxStamina(); diff --git a/src/main/java/com/alrex/parcool/client/hud/impl/StaminaHUD.java b/src/main/java/com/alrex/parcool/client/hud/impl/StaminaHUD.java index 7a37a775..6a241269 100644 --- a/src/main/java/com/alrex/parcool/client/hud/impl/StaminaHUD.java +++ b/src/main/java/com/alrex/parcool/client/hud/impl/StaminaHUD.java @@ -1,6 +1,7 @@ package com.alrex.parcool.client.hud.impl; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.client.hud.Position; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.capability.IStamina; @@ -10,7 +11,6 @@ import com.mojang.blaze3d.matrix.MatrixStack; import net.minecraft.client.MainWindow; import net.minecraft.client.Minecraft; -import net.minecraft.client.entity.player.ClientPlayerEntity; import net.minecraft.client.gui.AbstractGui; import net.minecraft.util.ResourceLocation; import net.minecraft.util.Tuple; @@ -34,7 +34,7 @@ public StaminaHUD() { private float oldStatusValue = 0f; private boolean showStatus = false; - public void onTick(TickEvent.ClientTickEvent event, ClientPlayerEntity player) { + public void onTick(TickEvent.ClientTickEvent event, ClientPlayerWrapper player) { Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; if (++renderGageTick >= 5) { @@ -64,7 +64,7 @@ public void onTick(TickEvent.ClientTickEvent event, ClientPlayerEntity player) { } public void render(RenderGameOverlayEvent.Post event, MatrixStack stack) { - ClientPlayerEntity player = Minecraft.getInstance().player; + ClientPlayerWrapper player = ClientPlayerWrapper.get(); if (player == null) return; if (player.isCreative()) return; diff --git a/src/main/java/com/alrex/parcool/client/hud/impl/StaminaHUDController.java b/src/main/java/com/alrex/parcool/client/hud/impl/StaminaHUDController.java index b02b06e3..d479902b 100644 --- a/src/main/java/com/alrex/parcool/client/hud/impl/StaminaHUDController.java +++ b/src/main/java/com/alrex/parcool/client/hud/impl/StaminaHUDController.java @@ -1,12 +1,11 @@ package com.alrex.parcool.client.hud.impl; import com.alrex.parcool.api.client.gui.ParCoolHUDEvent; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.stamina.Stamina; import com.alrex.parcool.config.ParCoolConfig; import com.mojang.blaze3d.matrix.MatrixStack; -import net.minecraft.client.Minecraft; -import net.minecraft.client.entity.player.ClientPlayerEntity; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.client.event.RenderGameOverlayEvent; @@ -24,7 +23,7 @@ public StaminaHUDController() { } public void onTick(TickEvent.ClientTickEvent event) { - ClientPlayerEntity player = Minecraft.getInstance().player; + ClientPlayerWrapper player = ClientPlayerWrapper.get(); if (player == null || player.isCreative()) return; lightStaminaHUD.onTick(event, player); staminaHUD.onTick(event, player); @@ -34,7 +33,7 @@ public void onTick(TickEvent.ClientTickEvent event) { } public void render(RenderGameOverlayEvent.Post event, MatrixStack stack) { - ClientPlayerEntity player = Minecraft.getInstance().player; + ClientPlayerWrapper player = ClientPlayerWrapper.get(); if (player == null) return; if (!ParCoolConfig.Client.Booleans.ParCoolIsActive.get() || !(IStamina.get(player) instanceof Stamina)) diff --git a/src/main/java/com/alrex/parcool/common/action/Action.java b/src/main/java/com/alrex/parcool/common/action/Action.java index 42e218e2..11463ee3 100644 --- a/src/main/java/com/alrex/parcool/common/action/Action.java +++ b/src/main/java/com/alrex/parcool/common/action/Action.java @@ -1,9 +1,9 @@ package com.alrex.parcool.common.action; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; -import net.minecraft.client.entity.player.ClientPlayerEntity; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.event.TickEvent; @@ -40,63 +40,63 @@ public void setDoing(boolean value) { } @OnlyIn(Dist.CLIENT) - public abstract boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo); + public abstract boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo); @OnlyIn(Dist.CLIENT) - public abstract boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina); + public abstract boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina); - public void onStart(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStart(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { } - public void onStartInServer(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInServer(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { } @OnlyIn(Dist.CLIENT) - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { } @OnlyIn(Dist.CLIENT) - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { } - public void onStop(PlayerEntity player) { + public void onStop(PlayerWrapper player) { } - public void onStopInServer(PlayerEntity player) { + public void onStopInServer(PlayerWrapper player) { } - public void onStopInOtherClient(PlayerEntity player) { + public void onStopInOtherClient(PlayerWrapper player) { } - public void onStopInLocalClient(PlayerEntity player) { + public void onStopInLocalClient(PlayerWrapper player) { } - public void onWorkingTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { } - public void onWorkingTickInServer(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInServer(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { } @OnlyIn(Dist.CLIENT) - public void onWorkingTickInClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { } @OnlyIn(Dist.CLIENT) - public void onWorkingTickInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { } - public void onTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { } - public void onServerTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onServerTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { } @OnlyIn(Dist.CLIENT) - public void onClientTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onClientTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { } @OnlyIn(Dist.CLIENT) - public void onRenderTick(TickEvent.RenderTickEvent event, PlayerEntity player, Parkourability parkourability) { + public void onRenderTick(TickEvent.RenderTickEvent event, PlayerWrapper player, Parkourability parkourability) { } public void restoreSynchronizedState(ByteBuffer buffer) { @@ -106,12 +106,12 @@ public void saveSynchronizedState(ByteBuffer buffer) { } @OnlyIn(Dist.CLIENT) - public boolean wantsToShowStatusBar(ClientPlayerEntity player, Parkourability parkourability) { + public boolean wantsToShowStatusBar(ClientPlayerWrapper player, Parkourability parkourability) { return false; } @OnlyIn(Dist.CLIENT) - public float getStatusValue(ClientPlayerEntity player, Parkourability parkourability) { + public float getStatusValue(ClientPlayerWrapper player, Parkourability parkourability) { return 0; } diff --git a/src/main/java/com/alrex/parcool/common/action/ActionProcessor.java b/src/main/java/com/alrex/parcool/common/action/ActionProcessor.java index 24f8d263..4704d995 100644 --- a/src/main/java/com/alrex/parcool/common/action/ActionProcessor.java +++ b/src/main/java/com/alrex/parcool/common/action/ActionProcessor.java @@ -1,22 +1,20 @@ package com.alrex.parcool.common.action; import com.alrex.parcool.ParCool; -import com.alrex.parcool.api.unstable.action.ParCoolActionEvent; +import com.alrex.parcool.api.compatibility.AbstractClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.EventBusWrapper; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.network.SyncActionStateMessage; import com.alrex.parcool.common.network.SyncStaminaMessage; -import net.minecraft.client.Minecraft; -import net.minecraft.client.entity.player.AbstractClientPlayerEntity; -import net.minecraft.client.entity.player.ClientPlayerEntity; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.text.TextFormatting; import net.minecraft.util.text.TranslationTextComponent; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.client.event.EntityViewRenderEvent; -import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.event.TickEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; import net.minecraftforge.fml.LogicalSide; @@ -36,7 +34,7 @@ public class ActionProcessor { public void onTickInClient(TickEvent.PlayerTickEvent event) { if (event.phase == TickEvent.Phase.START) return; if (event.side != LogicalSide.CLIENT) return; - AbstractClientPlayerEntity player = (AbstractClientPlayerEntity) event.player; + AbstractClientPlayerWrapper player = AbstractClientPlayerWrapper.get(event); Animation animation = Animation.get(player); if (animation == null) return; Parkourability parkourability = Parkourability.get(player); @@ -46,7 +44,7 @@ public void onTickInClient(TickEvent.PlayerTickEvent event) { @SubscribeEvent public void onTick(TickEvent.PlayerTickEvent event) { - PlayerEntity player = event.player; + PlayerWrapper player = PlayerWrapper.get(event); IStamina stamina = IStamina.get(player); if (stamina == null) return; if (event.phase == TickEvent.Phase.START) { @@ -59,11 +57,13 @@ public void onTick(TickEvent.PlayerTickEvent event) { boolean needSync = event.side == LogicalSide.CLIENT && player.isLocalPlayer(); SyncActionStateMessage.Encoder builder = SyncActionStateMessage.Encoder.reset(); - if (needSync && player.tickCount > 100 && player.tickCount % 150 == 0 && parkourability.limitationIsNotSynced()) { - if (player instanceof ClientPlayerEntity) { + int tickCount = player.getTickCount(); + if (needSync && tickCount > 100 && tickCount % 150 == 0 && parkourability.limitationIsNotSynced()) { + ClientPlayerWrapper clientPlayer = ClientPlayerWrapper.getOrDefault(player); + if (clientPlayer != null) { int trialCount = parkourability.getSynchronizeTrialCount(); if (trialCount < 5) { - parkourability.trySyncLimitation((ClientPlayerEntity) player); + parkourability.trySyncLimitation(clientPlayer); player.displayClientMessage(new TranslationTextComponent("parcool.message.error.limitation.not_synced"), false); ParCool.LOGGER.log(Level.WARN, "Detected ParCool Limitation is not synced. Sending synchronization request..."); } else if (trialCount == 5) { @@ -99,20 +99,21 @@ public void onTick(TickEvent.PlayerTickEvent event) { if (player.isLocalPlayer()) { if (action.isDoing()) { boolean canContinue = parkourability.getActionInfo().can(action.getClass()) - && !MinecraftForge.EVENT_BUS.post(new ParCoolActionEvent.TryToContinueEvent(player, action)) + && !EventBusWrapper.tryToContinueEvent(player, action) && action.canContinue(player, parkourability, stamina); if (!canContinue) { action.setDoing(false); action.onStopInLocalClient(player); action.onStop(player); - MinecraftForge.EVENT_BUS.post(new ParCoolActionEvent.StopEvent(player, action)); + EventBusWrapper.stopEvent(player, action); builder.appendFinishMsg(parkourability, action); } } else { + ParCool.LOGGER.info("Action {} is not doing", action.getClass().getSimpleName()); bufferOfStarting.clear(); boolean start = !player.isSpectator() && parkourability.getActionInfo().can(action.getClass()) - && !MinecraftForge.EVENT_BUS.post(new ParCoolActionEvent.TryToStartEvent(player, action)) + && !EventBusWrapper.tryToStartEvent(player, action) && action.canStart(player, parkourability, stamina, bufferOfStarting); bufferOfStarting.flip(); if (start) { @@ -121,7 +122,7 @@ public void onTick(TickEvent.PlayerTickEvent event) { bufferOfStarting.rewind(); action.onStartInLocalClient(player, parkourability, stamina, bufferOfStarting); bufferOfStarting.rewind(); - MinecraftForge.EVENT_BUS.post(new ParCoolActionEvent.StartEvent(player, action)); + EventBusWrapper.startEvent(player, action); builder.appendStartData(parkourability, action, bufferOfStarting); if (timing == StaminaConsumeTiming.OnStart) stamina.consume(parkourability.getActionInfo().getStaminaConsumptionOf(action.getClass())); @@ -179,9 +180,9 @@ public void onTick(TickEvent.PlayerTickEvent event) { @OnlyIn(Dist.CLIENT) @SubscribeEvent public void onRenderTick(TickEvent.RenderTickEvent event) { - PlayerEntity clientPlayer = Minecraft.getInstance().player; + PlayerWrapper clientPlayer = ClientPlayerWrapper.get(); if (clientPlayer == null) return; - for (PlayerEntity player : clientPlayer.level.players()) { + for (PlayerWrapper player : clientPlayer.getPlayersOnSameLevel()) { Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; List actions = parkourability.getList(); @@ -197,7 +198,7 @@ public void onRenderTick(TickEvent.RenderTickEvent event) { @OnlyIn(Dist.CLIENT) @SubscribeEvent public void onViewRender(EntityViewRenderEvent.CameraSetup event) { - ClientPlayerEntity player = Minecraft.getInstance().player; + ClientPlayerWrapper player = ClientPlayerWrapper.get(); if (player == null) return; Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; diff --git a/src/main/java/com/alrex/parcool/common/action/AdditionalProperties.java b/src/main/java/com/alrex/parcool/common/action/AdditionalProperties.java index 87633a20..2fef2c8b 100644 --- a/src/main/java/com/alrex/parcool/common/action/AdditionalProperties.java +++ b/src/main/java/com/alrex/parcool/common/action/AdditionalProperties.java @@ -1,7 +1,7 @@ package com.alrex.parcool.common.action; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; -import net.minecraft.entity.player.PlayerEntity; public class AdditionalProperties { private int sprintingTick = 0; @@ -22,7 +22,7 @@ public void onJump() { tickAfterLastJump = 0; } - public void onTick(PlayerEntity player, Parkourability parkourability) { + public void onTick(PlayerWrapper player, Parkourability parkourability) { tickAfterLastJump++; if (player.isSprinting()) { notSprintingTick = 0; @@ -50,7 +50,7 @@ public void onTick(PlayerEntity player, Parkourability parkourability) { notLandingTick++; landingTick = 0; } - if (player.abilities.flying) { + if (player.isFlying()) { notCreativeFlyingTick = 0; } else { notCreativeFlyingTick++; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/BreakfallReady.java b/src/main/java/com/alrex/parcool/common/action/impl/BreakfallReady.java index 32b39d7a..61d2da45 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/BreakfallReady.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/BreakfallReady.java @@ -1,13 +1,13 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.StaminaConsumeTiming; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.config.ParCoolConfig; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.vector.Vector3d; @@ -15,7 +15,7 @@ import java.util.Random; public class BreakfallReady extends Action { - public void startBreakfall(PlayerEntity player, Parkourability parkourability, IStamina stamina, boolean justTimed) { + public void startBreakfall(PlayerWrapper player, Parkourability parkourability, IStamina stamina, boolean justTimed) { boolean playSound = false; if (justTimed && ParCoolConfig.Client.Booleans.EnableJustTimeEffectOfBreakfall.get()) { if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) @@ -26,7 +26,7 @@ public void startBreakfall(PlayerEntity player, Parkourability parkourability, I Vector3d pos = player.position(); Random rand = player.getRandom(); for (int i = 0; i < 12; i++) { - player.level.addParticle(ParticleTypes.END_ROD, + player.addParticle(ParticleTypes.END_ROD, pos.x(), pos.y() + player.getBbHeight() / 2, pos.z(), @@ -54,12 +54,12 @@ public void startBreakfall(PlayerEntity player, Parkourability parkourability, I } @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { return canContinue(player, parkourability, stamina); } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return (KeyBindings.getKeyBreakfall().isDown() && !stamina.isExhausted() && !parkourability.get(Crawl.class).isDoing() diff --git a/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java b/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java index aff23896..08ee0629 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java @@ -1,6 +1,8 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.CatLeapAnimator; import com.alrex.parcool.client.input.KeyRecorder; import com.alrex.parcool.common.action.Action; @@ -11,8 +13,6 @@ import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.block.BlockRenderType; import net.minecraft.block.BlockState; -import net.minecraft.client.entity.player.ClientPlayerEntity; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; @@ -30,14 +30,14 @@ public class CatLeap extends Action { private static final int MAX_COOL_TIME_TICK = 30; @Override - public void onTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (coolTimeTick > 0) { coolTimeTick--; } } @Override - public void onClientTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onClientTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (player.isLocalPlayer()) { if (KeyRecorder.keySneak.isPressed() && parkourability.get(FastRun.class).getNotDashTick(parkourability.getAdditionalProperties()) < 10) { ready = true; @@ -54,7 +54,7 @@ public void onClientTick(PlayerEntity player, Parkourability parkourability, ISt @OnlyIn(Dist.CLIENT) @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { Vector3d movement = player.getDeltaMovement(); if (movement.lengthSqr() < 0.001) return false; movement = movement.multiply(1, 0, 1).normalize(); @@ -73,7 +73,7 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta @OnlyIn(Dist.CLIENT) @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return !((getDoingTick() > 1 && player.isOnGround()) || player.isFallFlying() || player.isInWaterOrBubble() @@ -82,7 +82,7 @@ public boolean canContinue(PlayerEntity player, Parkourability parkourability, I } @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { Vector3d jumpDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.CATLEAP.get(), 1, 1); @@ -96,7 +96,7 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { Vector3d jumpDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.CATLEAP.get(), 1, 1); @@ -106,12 +106,12 @@ public void onStartInOtherClient(PlayerEntity player, Parkourability parkourabil } @Override - public boolean wantsToShowStatusBar(ClientPlayerEntity player, Parkourability parkourability) { + public boolean wantsToShowStatusBar(ClientPlayerWrapper player, Parkourability parkourability) { return coolTimeTick > 0; } @Override - public float getStatusValue(ClientPlayerEntity player, Parkourability parkourability) { + public float getStatusValue(ClientPlayerWrapper player, Parkourability parkourability) { return coolTimeTick / (float) MAX_COOL_TIME_TICK; } @@ -121,9 +121,9 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { } @OnlyIn(Dist.CLIENT) - private void spawnJumpEffect(PlayerEntity player, Vector3d jumpDirection) { + private void spawnJumpEffect(PlayerWrapper player, Vector3d jumpDirection) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; - World level = player.level; + World level = player.getLevel(); Vector3d pos = player.position(); BlockPos blockpos = new BlockPos(pos.add(0, -0.2, 0)); if (!level.isLoaded(blockpos)) return; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/ChargeJump.java b/src/main/java/com/alrex/parcool/common/action/impl/ChargeJump.java index 3c1b94af..ecb90e69 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/ChargeJump.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/ChargeJump.java @@ -1,7 +1,9 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.unstable.action.ParCoolActionEvent; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.EventBusWrapper; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.ChargeJumpAnimator; import com.alrex.parcool.client.animation.impl.JumpChargingAnimator; import com.alrex.parcool.client.input.KeyRecorder; @@ -12,11 +14,7 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.client.entity.player.ClientPlayerEntity; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.vector.Vector3d; -import net.minecraftforge.common.MinecraftForge; - import java.nio.ByteBuffer; public class ChargeJump extends Action { @@ -29,14 +27,14 @@ public class ChargeJump extends Action { private boolean started = false; @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { boolean start = started; started = false; return start; } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return getDoingTick() < JUMP_ANIMATION_TICK; } @@ -46,7 +44,7 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { } @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { coolTimeTick = 30; if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.CHARGE_JUMP.get(), 1, 1); @@ -57,7 +55,7 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.CHARGE_JUMP.get(), 1, 1); Animation animation = Animation.get(player); @@ -67,9 +65,9 @@ public void onStartInOtherClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onClientTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { - if (player instanceof ClientPlayerEntity) { - ClientPlayerEntity cp = (ClientPlayerEntity) player; + public void onClientTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { + ClientPlayerWrapper cp = ClientPlayerWrapper.getOrDefault(player); + if (cp != null) { if (cp.isOnGround() && coolTimeTick <= 0 && !stamina.isExhausted() @@ -77,12 +75,9 @@ public void onClientTick(PlayerEntity player, Parkourability parkourability, ISt && !cp.isVisuallyCrawling() && !cp.isSprinting() && !cp.isInWaterOrBubble() - && !cp.input.up - && !cp.input.down - && !cp.input.right - && !cp.input.left + && !cp.isAnyMoveKeyDown() && !parkourability.get(Crawl.class).isDoing() - && !MinecraftForge.EVENT_BUS.post(new ParCoolActionEvent.TryToStartEvent(player, this)) + && !EventBusWrapper.tryToStartEvent(player, this) ) { if (cp.isShiftKeyDown() && KeyRecorder.keySneak.getPreviousTickNotKeyDown() > 5) { chargeTick++; @@ -95,8 +90,8 @@ public void onClientTick(PlayerEntity player, Parkourability parkourability, ISt notChargeTick++; } if (isCharging()) { - Vector3d targetAngle = VectorUtil.fromYawDegree(player.yHeadRot); - Vector3d currentAngle = VectorUtil.fromYawDegree(player.yBodyRot); + Vector3d targetAngle = VectorUtil.fromYawDegree(player.getYHeadRot()); + Vector3d currentAngle = VectorUtil.fromYawDegree(player.getYBodyRot()); double differenceAngle = Math.atan( (currentAngle.x() * targetAngle.z() - targetAngle.x() * currentAngle.z()) / (targetAngle.x() * currentAngle.x() + targetAngle.z() * currentAngle.z()) @@ -117,7 +112,7 @@ public void onClientTick(PlayerEntity player, Parkourability parkourability, ISt } } - public void onJump(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onJump(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { double power = chargeTick / (double) JUMP_MAX_CHARGE_TICK; if (power >= 0.5) { started = true; @@ -128,20 +123,17 @@ public void onJump(PlayerEntity player, Parkourability parkourability, IStamina } } if (started) { - player.setDeltaMovement(player.getDeltaMovement().add(0, 0.160 * power, 0)); + player.addToDeltaMovement(0, 0.160 * power, 0); } } - public void onLand(PlayerEntity player, Parkourability parkourability) { - if (player.isLocalPlayer() && player instanceof ClientPlayerEntity) { - ClientPlayerEntity cp = (ClientPlayerEntity) player; + public void onLand(PlayerWrapper player, Parkourability parkourability) { + ClientPlayerWrapper cp = ClientPlayerWrapper.getOrDefault(player); + if (player != null && player.isLocalPlayer()) { if ( parkourability.getActionInfo().can(ChargeJump.class) && coolTimeTick <= 0 - && !cp.input.up - && !cp.input.down - && !cp.input.right - && !cp.input.left + && !cp.isAnyMoveKeyDown() && (parkourability.get(FastRun.class).getNotDashTick(parkourability.getAdditionalProperties()) < 15) ) { chargeTick = JUMP_MAX_CHARGE_TICK + 5; @@ -152,12 +144,12 @@ public void onLand(PlayerEntity player, Parkourability parkourability) { } @Override - public boolean wantsToShowStatusBar(ClientPlayerEntity player, Parkourability parkourability) { + public boolean wantsToShowStatusBar(ClientPlayerWrapper player, Parkourability parkourability) { return isCharging(); } @Override - public float getStatusValue(ClientPlayerEntity player, Parkourability parkourability) { + public float getStatusValue(ClientPlayerWrapper player, Parkourability parkourability) { return ((float) getChargingTick()) / JUMP_MAX_CHARGE_TICK; } diff --git a/src/main/java/com/alrex/parcool/common/action/impl/ClimbPoles.java b/src/main/java/com/alrex/parcool/common/action/impl/ClimbPoles.java index 1e120a21..b64beb99 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/ClimbPoles.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/ClimbPoles.java @@ -1,21 +1,21 @@ package com.alrex.parcool.common.action.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.StaminaConsumeTiming; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; -import net.minecraft.entity.player.PlayerEntity; import java.nio.ByteBuffer; public class ClimbPoles extends Action { @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { return false; } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return false; } diff --git a/src/main/java/com/alrex/parcool/common/action/impl/ClimbUp.java b/src/main/java/com/alrex/parcool/common/action/impl/ClimbUp.java index c5f8793b..a7330fc7 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/ClimbUp.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/ClimbUp.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.ClimbUpAnimator; import com.alrex.parcool.client.input.KeyRecorder; import com.alrex.parcool.common.action.Action; @@ -9,7 +10,6 @@ import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.config.ParCoolConfig; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -19,7 +19,7 @@ public class ClimbUp extends Action { @OnlyIn(Dist.CLIENT) @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { ClingToCliff cling = parkourability.get(ClingToCliff.class); return cling.isDoing() && cling.getDoingTick() > 2 @@ -29,13 +29,13 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta @OnlyIn(Dist.CLIENT) @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return getDoingTick() < 2; } @OnlyIn(Dist.CLIENT) @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { Vector3d speed = player.getDeltaMovement(); player.setDeltaMovement(speed.x(), 0.6, speed.z()); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) @@ -45,7 +45,7 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.CLING_TO_CLIFF_JUMP.get(), 1f, 1f); Animation animation = Animation.get(player); diff --git a/src/main/java/com/alrex/parcool/common/action/impl/ClingToCliff.java b/src/main/java/com/alrex/parcool/common/action/impl/ClingToCliff.java index d7c3c42a..4acf7b00 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/ClingToCliff.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/ClingToCliff.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.ClingToCliffAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -13,7 +14,6 @@ import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.VectorUtil; import com.alrex.parcool.utilities.WorldUtil; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -39,8 +39,8 @@ public float getArmSwingAmount() { } @Override - public void onWorkingTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { - player.fallDistance = 0; + public void onWorkingTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { + player.resetFallDistance(); } public FacingDirection getFacingDirection() { @@ -49,7 +49,7 @@ public FacingDirection getFacingDirection() { @OnlyIn(Dist.CLIENT) @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { boolean value = (!stamina.isExhausted() && player.getDeltaMovement().y() < 0.2 && !parkourability.get(HorizontalWallRun.class).isDoing() @@ -67,7 +67,7 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta @OnlyIn(Dist.CLIENT) @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return (!stamina.isExhausted() && parkourability.getActionInfo().can(ClingToCliff.class) && isGrabbing() @@ -85,14 +85,14 @@ private boolean isGrabbing() { } @Override - public void onStart(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStart(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { parkourability.getBehaviorEnforcer().addMarkerCancellingFallFlying(ID_FALL_FLY_CANCEL, this::isDoing); armSwingAmount = 0; } @OnlyIn(Dist.CLIENT) @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { clingWallDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); facingDirection = FacingDirection.ToWall; armSwingAmount = 0; @@ -106,7 +106,7 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { clingWallDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); facingDirection = FacingDirection.ToWall; armSwingAmount = 0; @@ -118,7 +118,7 @@ public void onStartInOtherClient(PlayerEntity player, Parkourability parkourabil @OnlyIn(Dist.CLIENT) @Override - public void onWorkingTickInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { armSwingAmount += (float) player.getDeltaMovement().multiply(1, 0, 1).lengthSqr(); if (KeyBindings.isLeftAndRightDown()) { player.setDeltaMovement(0, 0, 0); @@ -135,7 +135,7 @@ public void onWorkingTickInLocalClient(PlayerEntity player, Parkourability parko } @Override - public void onWorkingTickInClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { clingWallDirection = WorldUtil.getGrabbableWall(player); if (clingWallDirection == null) return; clingWallDirection = clingWallDirection.normalize(); @@ -166,17 +166,17 @@ public void restoreSynchronizedState(ByteBuffer buffer) { @OnlyIn(Dist.CLIENT) @Override - public void onRenderTick(TickEvent.RenderTickEvent event, PlayerEntity player, Parkourability parkourability) { + public void onRenderTick(TickEvent.RenderTickEvent event, PlayerWrapper player, Parkourability parkourability) { if (isDoing() && clingWallDirection != null) { switch (facingDirection) { case ToWall: player.setYBodyRot((float) VectorUtil.toYawDegree(clingWallDirection)); break; case RightAgainstWall: - player.yBodyRotO = player.yBodyRot = (float) VectorUtil.toYawDegree(clingWallDirection.yRot((float) (-Math.PI / 2))); + player.rotateBodyRot0(clingWallDirection, -Math.PI / 2); break; case LeftAgainstWall: - player.yBodyRotO = player.yBodyRot = (float) VectorUtil.toYawDegree(clingWallDirection.yRot((float) (Math.PI / 2))); + player.rotateBodyRot0(clingWallDirection, Math.PI / 2); } } } diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Crawl.java b/src/main/java/com/alrex/parcool/common/action/impl/Crawl.java index 01b30750..9efac3a1 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Crawl.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Crawl.java @@ -1,5 +1,6 @@ package com.alrex.parcool.common.action.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.CrawlAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -10,7 +11,6 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.entity.Pose; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -25,7 +25,7 @@ public enum ControlType { @OnlyIn(Dist.CLIENT) @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { Pose pose = player.getPose(); return isActionInvoked(player) && disambiguateCommands(player, pose) @@ -39,17 +39,17 @@ && disambiguateCommands(player, pose) && (player.isOnGround() || ParCoolConfig.Client.Booleans.EnableCrawlInAir.get()); } - private boolean isActionInvoked(PlayerEntity player) { + private boolean isActionInvoked(PlayerWrapper player) { return ((ParCoolConfig.Client.CrawlControl.get() == ControlType.PressKey && KeyRecorder.keyCrawlState.isPressed()) || (ParCoolConfig.Client.CrawlControl.get() == ControlType.Toggle && toggleStatus)); } - private boolean disambiguateCommands(PlayerEntity player, Pose pose) { + private boolean disambiguateCommands(PlayerWrapper player, Pose pose) { // If crawl and dodge are bound to the same key, we'll crawl only when crouching return pose == Pose.CROUCHING || !KeyRecorder.keyDodge.isPressed(); } - public void onClientTick(PlayerEntity player, Parkourability parkourability) { + public void onClientTick(PlayerWrapper player, Parkourability parkourability) { if (player.isLocalPlayer()) { if (ParCoolConfig.Client.CrawlControl.get() == Crawl.ControlType.Toggle) { if (KeyRecorder.keyCrawlState.isPressed()) @@ -61,7 +61,7 @@ public void onClientTick(PlayerEntity player, Parkourability parkourability) { } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (!player.isVisuallyCrawling()) { switch (ParCoolConfig.Client.CrawlControl.get()) { case Toggle: @@ -85,7 +85,7 @@ public boolean canContinue(PlayerEntity player, Parkourability parkourability, I } @Override - public void onWorkingTickInClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { Animation animation = Animation.get(player); if (animation != null && !animation.hasAnimator()) { animation.setAnimator(new CrawlAnimator()); @@ -98,8 +98,7 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { } @Override - public void onWorkingTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { - player.setSprinting(false); - player.setPose(Pose.SWIMMING); + public void onWorkingTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { + player.setSwimming(); } } diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Dive.java b/src/main/java/com/alrex/parcool/common/action/impl/Dive.java index 9f84e659..e353620f 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Dive.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Dive.java @@ -1,5 +1,6 @@ package com.alrex.parcool.common.action.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.DiveAnimationHostAnimator; import com.alrex.parcool.client.animation.impl.DiveIntoWaterAnimator; import com.alrex.parcool.client.input.KeyRecorder; @@ -10,7 +11,6 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.BufferUtil; import com.alrex.parcool.utilities.WorldUtil; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.MathHelper; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -29,13 +29,13 @@ public double getPlayerYSpeed(float partialTick) { } @Override - public void onWorkingTickInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { playerYSpeedOld = playerYSpeed; playerYSpeed = player.getDeltaMovement().y(); } @Override - public void onClientTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onClientTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (isDoing() && (playerYSpeed < 0 || fallingTick > 0)) { fallingTick++; } else { @@ -45,7 +45,7 @@ public void onClientTick(PlayerEntity player, Parkourability parkourability, ISt @OnlyIn(Dist.CLIENT) @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { if (player.getVehicle() != null) return false; boolean startInAir = player.getDeltaMovement().y() < 0 && parkourability.getAdditionalProperties().getNotLandingTick() > 10 @@ -71,19 +71,19 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta @OnlyIn(Dist.CLIENT) @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return !(player.isFallFlying() - || player.abilities.flying + || player.isFlying() || player.isInWaterOrBubble() || player.isInLava() || player.isSwimming() || player.isOnGround() - || (fallingTick > 5 && player.fallDistance < 0.1) + || (fallingTick > 5 && player.getFallDistance() < 0.1) || stamina.isExhausted() ); } - public void onJump(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onJump(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (!player.isLocalPlayer()) return; initialYVelocityOfLastJump = player.getDeltaMovement().y(); justJumped = true; @@ -91,7 +91,7 @@ public void onJump(PlayerEntity player, Parkourability parkourability, IStamina @OnlyIn(Dist.CLIENT) @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { double initialYSpeed = startData.getDouble(); playerYSpeedOld = playerYSpeed = initialYSpeed; Animation animation = Animation.get(player); @@ -101,7 +101,7 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onStopInLocalClient(PlayerEntity player) { + public void onStopInLocalClient(PlayerWrapper player) { if (player.isInWaterOrBubble()) { Animation animation = Animation.get(player); Parkourability parkourability = Parkourability.get(player); @@ -116,7 +116,7 @@ public void onStopInLocalClient(PlayerEntity player) { } @Override - public void onStopInOtherClient(PlayerEntity player) { + public void onStopInOtherClient(PlayerWrapper player) { if (player.isInWaterOrBubble()) { Animation animation = Animation.get(player); Parkourability parkourability = Parkourability.get(player); @@ -149,7 +149,7 @@ public void restoreSynchronizedState(ByteBuffer buffer) { @OnlyIn(Dist.CLIENT) @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { double initialYSpeed = startData.getDouble(); playerYSpeedOld = playerYSpeed = initialYVelocityOfLastJump = initialYSpeed; Animation animation = Animation.get(player); diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Dodge.java b/src/main/java/com/alrex/parcool/common/action/impl/Dodge.java index b0ccb59f..b42130ce 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Dodge.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Dodge.java @@ -1,6 +1,8 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.DodgeAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -14,8 +16,6 @@ import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.extern.AdditionalMods; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.client.entity.player.ClientPlayerEntity; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -101,7 +101,7 @@ public DodgeDirection left() { @OnlyIn(Dist.CLIENT) @Override - public void onClientTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onClientTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (coolTime > 0) coolTime--; if (successivelyCoolTick > 0) { successivelyCoolTick--; @@ -124,7 +124,7 @@ public double getSpeedModifier(ActionInfo info) { @OnlyIn(Dist.CLIENT) @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { boolean enabledDoubleTap = ParCoolConfig.Client.Booleans.EnableDoubleTappingForDodge.get(); DodgeDirection direction = null; if (enabledDoubleTap) { @@ -157,19 +157,19 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta @OnlyIn(Dist.CLIENT) @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return !(parkourability.get(Roll.class).isDoing() || parkourability.get(ClingToCliff.class).isDoing() || getDoingTick() >= MAX_TICK || player.isInWaterOrBubble() || player.isFallFlying() - || player.abilities.flying + || player.isFlying() ); } @OnlyIn(Dist.CLIENT) @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { dodgeDirection = DodgeDirection.values()[startData.getInt()]; coolTime = getMaxCoolTime(parkourability.getActionInfo()); if (successivelyCount < getMaxSuccessiveDodge(parkourability.getActionInfo())) { @@ -209,7 +209,7 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil @OnlyIn(Dist.CLIENT) @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { dodgeDirection = DodgeDirection.values()[startData.getInt()]; if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.DODGE.get(), 1f, 1f); @@ -239,12 +239,12 @@ public float getCoolDownPhase(ActionInfo info) { } @Override - public boolean wantsToShowStatusBar(ClientPlayerEntity player, Parkourability parkourability) { + public boolean wantsToShowStatusBar(ClientPlayerWrapper player, Parkourability parkourability) { return coolTime > 0 || isInSuccessiveCoolDown(parkourability.getActionInfo()); } @Override - public float getStatusValue(ClientPlayerEntity player, Parkourability parkourability) { + public float getStatusValue(ClientPlayerWrapper player, Parkourability parkourability) { ActionInfo info = parkourability.getActionInfo(); int maxCoolTime = getMaxCoolTime(info); int successiveMaxCoolTime = getSuccessiveCoolTime(info); diff --git a/src/main/java/com/alrex/parcool/common/action/impl/FastRun.java b/src/main/java/com/alrex/parcool/common/action/impl/FastRun.java index b37dd98c..ed3d3b57 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/FastRun.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/FastRun.java @@ -1,5 +1,6 @@ package com.alrex.parcool.common.action.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.FastRunningAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -14,7 +15,6 @@ import net.minecraft.entity.ai.attributes.AttributeModifier; import net.minecraft.entity.ai.attributes.Attributes; import net.minecraft.entity.ai.attributes.ModifiableAttributeInstance; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -40,7 +40,7 @@ public double getSpeedModifier(ActionInfo info) { } @Override - public void onServerTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onServerTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { ModifiableAttributeInstance attr = player.getAttribute(Attributes.MOVEMENT_SPEED); if (attr == null) return; if (attr.getModifier(FAST_RUNNING_MODIFIER_UUID) != null) attr.removeModifier(FAST_RUNNING_MODIFIER_UUID); @@ -56,7 +56,7 @@ public void onServerTick(PlayerEntity player, Parkourability parkourability, ISt } @Override - public void onClientTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onClientTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (player.isLocalPlayer()) { if (ParCoolConfig.Client.FastRunControl.get() == ControlType.Toggle && parkourability.getAdditionalProperties().getSprintingTick() > 3 @@ -75,12 +75,12 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { } @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { return canContinue(player, parkourability, stamina); } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return (!stamina.isExhausted() && !player.isInWaterOrBubble() && player.getVehicle() == null @@ -100,7 +100,7 @@ public boolean canContinue(PlayerEntity player, Parkourability parkourability, I } @Override - public void onWorkingTickInClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { Animation animation = Animation.get(player); if (animation != null && !animation.hasAnimator()) { animation.setAnimator(new FastRunningAnimator()); @@ -108,19 +108,19 @@ public void onWorkingTickInClient(PlayerEntity player, Parkourability parkourabi } @Override - public void onStartInServer(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInServer(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { speedModifier = getSpeedModifier(parkourability.getActionInfo()); } @Override - public void onStopInLocalClient(PlayerEntity player) { + public void onStopInLocalClient(PlayerWrapper player) { Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; lastDashTick = getDashTick(parkourability.getAdditionalProperties()); } @OnlyIn(Dist.CLIENT) - public boolean canActWithRunning(PlayerEntity player) { + public boolean canActWithRunning(PlayerWrapper player) { return ParCoolConfig.Client.Booleans.SubstituteSprintForFastRun.get() ? player.isSprinting() : this.isDoing(); } diff --git a/src/main/java/com/alrex/parcool/common/action/impl/FastSwim.java b/src/main/java/com/alrex/parcool/common/action/impl/FastSwim.java index 37384e6a..bf4c2150 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/FastSwim.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/FastSwim.java @@ -1,5 +1,6 @@ package com.alrex.parcool.common.action.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.FastSwimAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -12,7 +13,6 @@ import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.entity.ai.attributes.AttributeModifier; import net.minecraft.entity.ai.attributes.ModifiableAttributeInstance; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.common.ForgeMod; import java.nio.ByteBuffer; @@ -32,12 +32,12 @@ public double getSpeedModifier(ActionInfo info) { } @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { return canContinue(player, parkourability, stamina); } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return (!stamina.isExhausted() && player.isInWaterOrBubble() && player.getVehicle() == null @@ -52,7 +52,7 @@ public boolean canContinue(PlayerEntity player, Parkourability parkourability, I } @Override - public void onClientTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onClientTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (player.isLocalPlayer()) { if (ParCoolConfig.Client.FastRunControl.get() == FastRun.ControlType.Toggle && parkourability.getAdditionalProperties().getSprintingTick() > 3 @@ -68,7 +68,7 @@ public void onClientTick(PlayerEntity player, Parkourability parkourability, ISt } @Override - public void onWorkingTickInClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { Animation animation = Animation.get(player); if (animation != null && !animation.hasAnimator()) { animation.setAnimator(new FastSwimAnimator()); @@ -76,12 +76,12 @@ public void onWorkingTickInClient(PlayerEntity player, Parkourability parkourabi } @Override - public void onStartInServer(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInServer(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { speedModifier = parkourability.get(FastSwim.class).getSpeedModifier(parkourability.getActionInfo()); } @Override - public void onServerTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onServerTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { ModifiableAttributeInstance attr = player.getAttribute(ForgeMod.SWIM_SPEED.get()); if (attr == null) return; if (attr.getModifier(FAST_SWIM_MODIFIER_UUID) != null) attr.removeModifier(FAST_SWIM_MODIFIER_UUID); diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Flipping.java b/src/main/java/com/alrex/parcool/common/action/impl/Flipping.java index b7f26d7c..928ba0bb 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Flipping.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Flipping.java @@ -1,5 +1,6 @@ package com.alrex.parcool.common.action.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.FlippingAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -9,7 +10,6 @@ import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.config.ParCoolConfig; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -45,11 +45,11 @@ public enum Direction { private boolean justJumped = false; - public void onJump(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onJump(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { justJumped = true; } @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { Direction fDirection; if (KeyBindings.isKeyBackDown()) { fDirection = Direction.Back; @@ -74,12 +74,12 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return !player.isOnGround() || getDoingTick() <= 10; } @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { ControlType control = ControlType.values()[startData.getInt()]; if (control != ControlType.TapMovementAndJump) player.jumpFromGround(); stamina.consume(parkourability.getActionInfo().getStaminaConsumptionOf(Flipping.class)); @@ -92,7 +92,7 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { startData.position(4); // skip (int * 1) Animation animation = Animation.get(player); if (animation != null) { diff --git a/src/main/java/com/alrex/parcool/common/action/impl/HangDown.java b/src/main/java/com/alrex/parcool/common/action/impl/HangDown.java index 236ac557..701445d4 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/HangDown.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/HangDown.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.HangAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; @@ -12,7 +13,6 @@ import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.VectorUtil; import com.alrex.parcool.utilities.WorldUtil; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -52,7 +52,7 @@ public BarAxis getHangingBarAxis() { @OnlyIn(Dist.CLIENT) @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { startInfo.putDouble(Math.max(-1, Math.min(1, 3 * player.getLookAngle().multiply(1, 0, 1).normalize().dot(player.getDeltaMovement())))); return (!stamina.isExhausted() && Math.abs(player.getDeltaMovement().y()) < 0.2 @@ -66,7 +66,7 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta @OnlyIn(Dist.CLIENT) @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return (!stamina.isExhausted() && KeyBindings.getKeyHangDown().isDown() && parkourability.getActionInfo().can(HangDown.class) @@ -76,11 +76,11 @@ public boolean canContinue(PlayerEntity player, Parkourability parkourability, I ); } - private void setup(PlayerEntity player, ByteBuffer startData) { + private void setup(PlayerWrapper player, ByteBuffer startData) { armSwingAmount = 0; bodySwingAngleFactor = startData.getDouble(); hangingBarAxis = WorldUtil.getHangableBars(player); - Vector3d bodyVec = VectorUtil.fromYawDegree(player.yBodyRot); + Vector3d bodyVec = VectorUtil.fromYawDegree(player.getYBodyRot()); orthogonalToBar = (hangingBarAxis == BarAxis.X && Math.abs(bodyVec.x()) < Math.abs(bodyVec.z())) || (hangingBarAxis == BarAxis.Z && Math.abs(bodyVec.z()) < Math.abs(bodyVec.x())); player.setDeltaMovement(0, 0, 0); @@ -90,7 +90,7 @@ private void setup(PlayerEntity player, ByteBuffer startData) { @OnlyIn(Dist.CLIENT) @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { setup(player, startData); if (!KeyBindings.getKeyHangDown().getKey().equals(KeyBindings.getKeySneak().getKey())) { parkourability.getBehaviorEnforcer().addMarkerCancellingSneak(ID_SNEAK_CANCEL, this::isDoing); @@ -101,7 +101,7 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { setup(player, startData); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) { player.playSound(SoundEvents.HANG_DOWN.get(), 1.0f, 1.0f); @@ -110,8 +110,8 @@ public void onStartInOtherClient(PlayerEntity player, Parkourability parkourabil @OnlyIn(Dist.CLIENT) @Override - public void onWorkingTickInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { - Vector3d bodyVec = VectorUtil.fromYawDegree(player.yBodyRot); + public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { + Vector3d bodyVec = VectorUtil.fromYawDegree(player.getYBodyRot()); final double speed = 0.1; double xSpeed = 0, zSpeed = 0; if (orthogonalToBar) { @@ -137,9 +137,9 @@ public void onWorkingTickInLocalClient(PlayerEntity player, Parkourability parko } @Override - public void onWorkingTickInClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { hangingBarAxis = WorldUtil.getHangableBars(player); - Vector3d bodyVec = VectorUtil.fromYawDegree(player.yBodyRot); + Vector3d bodyVec = VectorUtil.fromYawDegree(player.getYBodyRot()); orthogonalToBar = (hangingBarAxis == BarAxis.X && Math.abs(bodyVec.x()) < Math.abs(bodyVec.z())) || (hangingBarAxis == BarAxis.Z && Math.abs(bodyVec.z()) < Math.abs(bodyVec.x())); @@ -162,10 +162,10 @@ public void restoreSynchronizedState(ByteBuffer buffer) { @OnlyIn(Dist.CLIENT) @Override - public void onRenderTick(TickEvent.RenderTickEvent event, PlayerEntity player, Parkourability parkourability) { + public void onRenderTick(TickEvent.RenderTickEvent event, PlayerWrapper player, Parkourability parkourability) { if (isDoing()) { if (hangingBarAxis == null) return; - Vector3d bodyVec = VectorUtil.fromYawDegree(player.yBodyRot).normalize(); + Vector3d bodyVec = VectorUtil.fromYawDegree(player.getYBodyRot()).normalize(); Vector3d lookVec = player.getLookAngle(); Vector3d idealLookVec; if (Math.abs(lookVec.x()) > Math.abs(lookVec.z())) { diff --git a/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java b/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java index 1e5c7826..1efb06e9 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java @@ -1,5 +1,6 @@ package com.alrex.parcool.common.action.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.RenderBehaviorEnforcer; import com.alrex.parcool.client.animation.impl.HideInBlockAnimator; import com.alrex.parcool.client.input.KeyBindings; @@ -14,7 +15,6 @@ import net.minecraft.client.Minecraft; import net.minecraft.client.settings.PointOfView; import net.minecraft.entity.Pose; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.Tuple; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.BlockRayTraceResult; @@ -46,9 +46,9 @@ public Vector3d getLookDirection() { } @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { if (player.isSprinting() - || player.noPhysics + || player.hasNoPhysics() || !player.isOnGround() || player.isInWater() || player.isPassenger() @@ -56,7 +56,7 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta || parkourability.isDoingNothing() || !KeyBindings.getKeyBindHideInBlock().isDown() || getNotDoingTick() < 6 - || player.hurtTime > 0 + || player.hasHurtTime() || player.getPose() != Pose.CROUCHING ) { return false; @@ -107,17 +107,17 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (hidingBlockChanged) { return hidingBlockChanged = false; } - return player.hurtTime <= 0 + return !player.hasHurtTime() && player.getPose() == Pose.STANDING && (getDoingTick() < 6 || KeyBindings.getKeyBindHideInBlock().isDown() || KeyBindings.getKeySneak().isDown()); } @Override - public void onStart(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStart(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { boolean _stand = BufferUtil.getBoolean(startData); hidingArea = new Tuple<>(BufferUtil.getBlockPos(startData), BufferUtil.getBlockPos(startData)); hidingPoint = BufferUtil.getVector3d(startData); @@ -132,13 +132,13 @@ public void onStart(PlayerEntity player, Parkourability parkourability, ByteBuff } ); parkourability.getBehaviorEnforcer().addMarkerCancellingSneak(ID_SNEAK, this::isDoing); - player.setPose(Pose.STANDING); - player.noPhysics = true; - player.playSound(player.level.getBlockState(new BlockPos(hidingPoint.add(0, 0.2, 0))).getSoundType().getBreakSound(), 1, 1); + player.setStandingPose(); + player.disablePhysics(); + player.playSound(player.getBlockState(new BlockPos(hidingPoint.add(0, 0.2, 0))).getSoundType().getBreakSound(), 1, 1); } @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { boolean stand = BufferUtil.getBoolean(startData); RenderBehaviorEnforcer.serMarkerEnforceCameraType(this::isDoing, () -> PointOfView.THIRD_PERSON_BACK); parkourability.getBehaviorEnforcer().addMarkerCancellingShowName(ID_SHOW_NAME, this::isDoing); @@ -149,7 +149,7 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { boolean stand = BufferUtil.getBoolean(startData); Animation animation = Animation.get(player); parkourability.getBehaviorEnforcer().addMarkerCancellingShowName(ID_SHOW_NAME, this::isDoing); @@ -160,21 +160,21 @@ public void onStartInOtherClient(PlayerEntity player, Parkourability parkourabil @Override - public void onWorkingTickInServer(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInServer(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (hidingPoint == null) return; - player.setPos(hidingPoint.x(), hidingPoint.y(), hidingPoint.z()); + player.setPos(hidingPoint); } @Override - public void onWorkingTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { player.setDeltaMovement(Vector3d.ZERO); - player.noPhysics = true; + player.disablePhysics(); player.setSprinting(false); - player.setPose(Pose.STANDING); + player.setStandingPose(); } @Override - public void onStopInLocalClient(PlayerEntity player) { + public void onStopInLocalClient(PlayerWrapper player) { final Vector3d hidePos = hidingPoint; final Vector3d entPos = enterPoint; Parkourability parkourability = Parkourability.get(player); @@ -188,35 +188,35 @@ public void onStopInLocalClient(PlayerEntity player) { } ); spawnOnHideParticles(player); - player.playSound(player.level.getBlockState(new BlockPos(hidingPoint.add(0, 0.2, 0))).getSoundType().getBreakSound(), 1, 1); + player.playSound(player.getBlockState(new BlockPos(hidingPoint.add(0, 0.2, 0))).getSoundType().getBreakSound(), 1, 1); } @Override - public void onTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (!isDoing() && getNotDoingTick() <= 1) { - player.noPhysics = true; + player.disablePhysics();; } } @Override - public void onStopInOtherClient(PlayerEntity player) { + public void onStopInOtherClient(PlayerWrapper player) { spawnOnHideParticles(player); - player.playSound(player.level.getBlockState(new BlockPos(hidingPoint.add(0, 0.2, 0))).getSoundType().getBreakSound(), 1, 1); + player.playSound(player.getBlockState(new BlockPos(hidingPoint.add(0, 0.2, 0))).getSoundType().getBreakSound(), 1, 1); } @Override - public void onStop(PlayerEntity player) { + public void onStop(PlayerWrapper player) { hidingPoint = null; enterPoint = null; hidingArea = null; lookDirection = null; - player.noPhysics = false; + player.enablePhysics(); } @OnlyIn(Dist.CLIENT) - private void spawnOnHideParticles(PlayerEntity player) { + private void spawnOnHideParticles(PlayerWrapper player) { if (hidingArea == null) return; - World world = player.level; + World world = player.getLevel(); int minX = hidingArea.getA().getX(); int minY = hidingArea.getA().getY(); int minZ = hidingArea.getA().getZ(); diff --git a/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java b/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java index 2ea673dd..4d543755 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.HorizontalWallRunAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; @@ -17,7 +18,6 @@ import net.minecraft.block.BlockState; import net.minecraft.entity.ai.attributes.Attributes; import net.minecraft.entity.ai.attributes.ModifiableAttributeInstance; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; @@ -47,18 +47,18 @@ private int getMaxRunningTick(ActionInfo info) { private Vector3d runningDirection = null; @Override - public void onClientTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onClientTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (coolTime > 0) coolTime--; } @OnlyIn(Dist.CLIENT) @Override - public void onWorkingTickInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { Vector3d wallDirection = WorldUtil.getRunnableWall(player, player.getBbWidth() * 0.65f); if (wallDirection == null) return; if (runningWallDirection == null) return; if (runningDirection == null) return; - Vector3d lookVec = VectorUtil.fromYawDegree(player.yBodyRot); + Vector3d lookVec = VectorUtil.fromYawDegree(player.getYBodyRot()); double differenceAngle = Math.asin( new Vector3d( lookVec.x() * runningDirection.x() + lookVec.z() * runningDirection.z(), 0, @@ -72,8 +72,8 @@ public void onWorkingTickInLocalClient(PlayerEntity player, Parkourability parko player.getBoundingBox().minY + player.getBbHeight() * 0.5, player.getZ() + runningWallDirection.z() ); - if (!player.level.isLoaded(leanedBlock)) return; - float slipperiness = player.level.getBlockState(leanedBlock).getSlipperiness(player.level, leanedBlock, player); + if (!player.isEveryLoaded(leanedBlock)) return; + float slipperiness = player.getSlipperiness(leanedBlock); if (slipperiness <= 0.8) { double speedScale = 0.2; ModifiableAttributeInstance attr = player.getAttribute(Attributes.MOVEMENT_SPEED); @@ -90,11 +90,11 @@ public void onWorkingTickInLocalClient(PlayerEntity player, Parkourability parko @OnlyIn(Dist.CLIENT) @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { Vector3d wallDirection = WorldUtil.getRunnableWall(player, player.getBbWidth() * 0.65f); if (wallDirection == null) return false; Vector3d wallVec = wallDirection.normalize(); - Vector3d lookDirection = VectorUtil.fromYawDegree(player.yBodyRot); + Vector3d lookDirection = VectorUtil.fromYawDegree(player.getYBodyRot()); lookDirection = new Vector3d(lookDirection.x(), 0, lookDirection.z()).normalize(); //doing "wallDirection/direction" as complex number(x + z i) to calculate difference of player's direction to steps Vector3d dividedVec = @@ -139,7 +139,7 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta @OnlyIn(Dist.CLIENT) @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { Vector3d wallDirection = WorldUtil.getRunnableWall(player, player.getBbWidth() * 0.65f); if (wallDirection == null) return false; return (getDoingTick() < getMaxRunningTick(parkourability.getActionInfo()) @@ -157,12 +157,12 @@ public boolean canContinue(PlayerEntity player, Parkourability parkourability, I } @Override - public void onStop(PlayerEntity player) { + public void onStop(PlayerWrapper player) { coolTime = 10; } @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { wallIsRightward = BufferUtil.getBoolean(startData); runningWallDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); runningDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); @@ -175,7 +175,7 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { wallIsRightward = BufferUtil.getBoolean(startData); runningWallDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); runningDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); @@ -189,7 +189,7 @@ public void onStartInOtherClient(PlayerEntity player, Parkourability parkourabil @OnlyIn(Dist.CLIENT) @Override - public void onRenderTick(TickEvent.RenderTickEvent event, PlayerEntity player, Parkourability parkourability) { + public void onRenderTick(TickEvent.RenderTickEvent event, PlayerWrapper player, Parkourability parkourability) { if (isDoing()) { if (runningDirection == null) return; Vector3d lookVec = VectorUtil.fromYawDegree(player.getYHeadRot()); @@ -200,16 +200,16 @@ public void onRenderTick(TickEvent.RenderTickEvent event, PlayerEntity player, P ).normalize().z() ); if (Math.abs(differenceAngle) > Math.PI / 4) { - player.yRot = ((float) VectorUtil.toYawDegree( + player.setYRot((float) VectorUtil.toYawDegree( runningDirection.yRot((float) (-Math.signum(differenceAngle) * Math.PI / 4)) )); } - player.yBodyRotO = player.yBodyRot = bodyYaw; + player.setAllYBodyRot(bodyYaw); } } @Override - public void onWorkingTickInClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { spawnRunningParticle(player); } @@ -229,10 +229,10 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { } @OnlyIn(Dist.CLIENT) - public void spawnRunningParticle(PlayerEntity player) { + public void spawnRunningParticle(PlayerWrapper player) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; if (runningDirection == null || runningWallDirection == null) return; - World level = player.level; + World level = player.getLevel(); Vector3d pos = player.position(); BlockPos leanedBlock = new BlockPos( pos.add(runningWallDirection.x(), player.getBbHeight() * 0.25, runningWallDirection.z()) diff --git a/src/main/java/com/alrex/parcool/common/action/impl/JumpFromBar.java b/src/main/java/com/alrex/parcool/common/action/impl/JumpFromBar.java index ccaa1140..6ed22b37 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/JumpFromBar.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/JumpFromBar.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.JumpFromBarAnimator; import com.alrex.parcool.client.input.KeyRecorder; import com.alrex.parcool.common.action.Action; @@ -10,13 +11,12 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.EntityUtil; -import net.minecraft.entity.player.PlayerEntity; import java.nio.ByteBuffer; public class JumpFromBar extends Action { @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { HangDown hangDown = parkourability.get(HangDown.class); return hangDown.isDoing() && hangDown.getDoingTick() > 2 @@ -24,12 +24,12 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return getDoingTick() < 2; } @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { EntityUtil.addVelocity(player, player.getLookAngle().multiply(1, 0, 1).normalize().scale(player.getBbWidth() * 0.75)); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.HANG_DOWN_JUMP.get(), 1f, 1f); @@ -38,7 +38,7 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.HANG_DOWN_JUMP.get(), 1f, 1f); Animation animation = Animation.get(player); diff --git a/src/main/java/com/alrex/parcool/common/action/impl/QuickTurn.java b/src/main/java/com/alrex/parcool/common/action/impl/QuickTurn.java index 45bb622b..b61910ad 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/QuickTurn.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/QuickTurn.java @@ -1,12 +1,12 @@ package com.alrex.parcool.common.action.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.input.KeyRecorder; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.StaminaConsumeTiming; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.event.TickEvent; @@ -18,7 +18,7 @@ public class QuickTurn extends Action { private Vector3d startAngle = null; @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { Vector3d angle = player.getLookAngle(); startInfo .putDouble(angle.x()) @@ -31,12 +31,12 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return getDoingTick() < AnimationTickLength; } @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { turnRightward = !turnRightward; startAngle = new Vector3d( startData.getDouble(), @@ -46,12 +46,12 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onRenderTick(TickEvent.RenderTickEvent event, PlayerEntity player, Parkourability parkourability) { + public void onRenderTick(TickEvent.RenderTickEvent event, PlayerWrapper player, Parkourability parkourability) { if (isDoing() && startAngle != null) { float renderTick = getDoingTick() + event.renderTickTime; float animationPhase = renderTick / AnimationTickLength; Vector3d rotatedAngle = startAngle.yRot((float) (Math.PI * animationPhase * (turnRightward ? -1 : 1))); - player.yRot = (float) VectorUtil.toYawDegree(rotatedAngle); + player.setYRot(VectorUtil.toYawDegree(rotatedAngle)); } } diff --git a/src/main/java/com/alrex/parcool/common/action/impl/RideZipline.java b/src/main/java/com/alrex/parcool/common/action/impl/RideZipline.java index 9b13990d..61753b1a 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/RideZipline.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/RideZipline.java @@ -1,5 +1,6 @@ package com.alrex.parcool.common.action.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.RideZiplineAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -13,7 +14,6 @@ import com.alrex.parcool.common.zipline.Zipline; import com.alrex.parcool.utilities.BufferUtil; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.MathHelper; import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.common.ForgeMod; @@ -49,7 +49,7 @@ public Vector3d getEndOffsetFromStart() { } @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { if (KeyBindings.getKeyBindRideZipline().isDown() && !player.isOnGround() && !player.isInWater() @@ -65,7 +65,7 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta && !parkourability.get(HorizontalWallRun.class).isDoing() && !parkourability.get(VerticalWallRun.class).isDoing() ) { - ZiplineRopeEntity ropeEntity = Zipline.getHangableZipline(player.level, player); + ZiplineRopeEntity ropeEntity = Zipline.getHangableZipline(player.getLevel(), player); if (ropeEntity == null) return false; double t = ropeEntity.getZipline().getParameter(player.position()); if (t < 0 || 1 < t) return false; @@ -77,7 +77,7 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return KeyBindings.getKeyBindRideZipline().isDown() && !KeyRecorder.keyJumpState.isPressed() && !player.isInWall() @@ -85,12 +85,11 @@ public boolean canContinue(PlayerEntity player, Parkourability parkourability, I && ridingZipline != null && ridingZipline.isAlive() && 0 <= currentT && currentT <= 1 - && !player.horizontalCollision - && !player.verticalCollision; + && !player.hasSomeCollision(); } @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { if (ridingZipline == null) { return; } @@ -112,21 +111,21 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { Animation animation = Animation.get(player); if (animation == null) return; animation.setAnimator(new RideZiplineAnimator()); } @Override - public void onStart(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStart(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { endOffsetFromStart = BufferUtil.getVector3d(startData); player.setSprinting(false); parkourability.getBehaviorEnforcer().addMarkerCancellingFallFlying(ID_FALL_FLY_CANCEL, this::isDoing); } @Override - public void onWorkingTickInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (ridingZipline == null) return; double oldSpeed = speed; Zipline zipline = ridingZipline.getZipline(); @@ -200,13 +199,13 @@ public void restoreSynchronizedState(ByteBuffer buffer) { } @Override - public void onWorkingTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { - player.fallDistance = 0; + public void onWorkingTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { + player.resetFallDistance(); player.setDeltaMovement(Vector3d.ZERO); } @Override - public void onStopInLocalClient(PlayerEntity player) { + public void onStopInLocalClient(PlayerWrapper player) { if (ridingZipline != null) { player.setDeltaMovement( getDeltaMovement(ridingZipline.getZipline(), speed, currentT) @@ -222,7 +221,7 @@ public void onStopInLocalClient(PlayerEntity player) { @Override - public void onStop(PlayerEntity player) { + public void onStop(PlayerWrapper player) { ridingZipline = null; } diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Roll.java b/src/main/java/com/alrex/parcool/common/action/impl/Roll.java index 80b7e2e7..23cb03f2 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Roll.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Roll.java @@ -1,5 +1,7 @@ package com.alrex.parcool.common.action.impl; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.RollAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; @@ -10,8 +12,6 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.client.entity.player.ClientPlayerEntity; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -27,7 +27,7 @@ public enum Direction {Front, Back, Left, Right} @OnlyIn(Dist.CLIENT) @Override - public void onClientTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onClientTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (player.isLocalPlayer()) { if (KeyBindings.getKeyBreakfall().isDown() && KeyBindings.isKeyForwardDown() @@ -55,14 +55,15 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { } @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { - ClientPlayerEntity clientPlayer = (ClientPlayerEntity) player; + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + ClientPlayerWrapper clientPlayer = ClientPlayerWrapper.get(player); Direction rollDirection = Direction.Front; - if (clientPlayer.input.leftImpulse < -0.5) { + double leftImpulse = clientPlayer.getLeftImpulse(); + if (leftImpulse < -0.5) { rollDirection = Direction.Right; - } else if (clientPlayer.input.leftImpulse > 0.5) { + } else if (leftImpulse > 0.5) { rollDirection = Direction.Left; - } else if (clientPlayer.input.forwardImpulse < -0.5) { + } else if (clientPlayer.getForwardImpulse() < -0.5) { rollDirection = Direction.Back; } startInfo.putInt(rollDirection.ordinal()); @@ -71,12 +72,12 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return getDoingTick() < getRollMaxTick(); } @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { startRequired = false; Direction direction = Direction.values()[startData.getInt()]; Animation animation = Animation.get(player); @@ -84,11 +85,11 @@ public void onStartInOtherClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { startRequired = false; Direction direction = Direction.values()[startData.getInt()]; double modifier = Math.sqrt(player.getBbWidth()); - Vector3d vec = VectorUtil.fromYawDegree(player.yBodyRot).scale(modifier); + Vector3d vec = VectorUtil.fromYawDegree(player.getYBodyRot()).scale(modifier); switch (direction) { case Back: vec = vec.reverse(); @@ -106,7 +107,7 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil parkourability.getBehaviorEnforcer().addMarkerCancellingJump(ID_JUMP_CANCEL, this::isDoing); } - public void startRoll(PlayerEntity player) { + public void startRoll(PlayerWrapper player) { startRequired = true; } diff --git a/src/main/java/com/alrex/parcool/common/action/impl/SkyDive.java b/src/main/java/com/alrex/parcool/common/action/impl/SkyDive.java index 82fb7a41..89a15dc7 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/SkyDive.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/SkyDive.java @@ -1,13 +1,13 @@ package com.alrex.parcool.common.action.impl; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.input.KeyRecorder; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.StaminaConsumeTiming; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.client.entity.player.ClientPlayerEntity; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.event.TickEvent; @@ -15,7 +15,7 @@ public class SkyDive extends Action { @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { return parkourability.get(Dive.class).getDoingTick() > 15 && !stamina.isExhausted() && getNotDoingTick() > 20 @@ -23,19 +23,17 @@ && getNotDoingTick() > 20 } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return parkourability.get(Dive.class).isDoing() && !KeyRecorder.keyJumpState.isPressed(); } @Override - public void onWorkingTickInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { - if (!(player instanceof ClientPlayerEntity)) { - return; - } - ClientPlayerEntity clientPlayer = (ClientPlayerEntity) player; - Vector3d forwardVec = VectorUtil.fromYawDegree(player.yHeadRot); - Vector3d leftVec = forwardVec.yRot((float) Math.PI / 2).scale(clientPlayer.input.leftImpulse * 0.0); - forwardVec = forwardVec.scale(clientPlayer.input.forwardImpulse * 0.03); + public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { + if (!player.isLocalPlayer()) return; + ClientPlayerWrapper clientPlayer = ClientPlayerWrapper.get(player); + Vector3d forwardVec = VectorUtil.fromYawDegree(player.getYHeadRot()); + Vector3d leftVec = forwardVec.yRot((float) Math.PI / 2).scale(clientPlayer.getLeftImpulse() * 0.0); + forwardVec = forwardVec.scale(clientPlayer.getForwardImpulse() * 0.03); clientPlayer.setDeltaMovement(clientPlayer.getDeltaMovement() .multiply(1, 0.98, 1).add( forwardVec.add(leftVec) @@ -43,8 +41,8 @@ public void onWorkingTickInLocalClient(PlayerEntity player, Parkourability parko } @Override - public void onRenderTick(TickEvent.RenderTickEvent event, PlayerEntity player, Parkourability parkourability) { - if (isDoing()) player.setYBodyRot(player.yHeadRot); + public void onRenderTick(TickEvent.RenderTickEvent event, PlayerWrapper player, Parkourability parkourability) { + if (isDoing()) player.setYBodyRot(player.getYHeadRot()); } @Override diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Slide.java b/src/main/java/com/alrex/parcool/common/action/impl/Slide.java index c8f3ad74..7b0f3817 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Slide.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Slide.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.CrawlAnimator; import com.alrex.parcool.client.animation.impl.SlidingAnimator; import com.alrex.parcool.client.input.KeyRecorder; @@ -15,7 +16,6 @@ import net.minecraft.block.BlockState; import net.minecraft.entity.ai.attributes.Attributes; import net.minecraft.entity.ai.attributes.ModifiableAttributeInstance; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; @@ -32,7 +32,7 @@ public class Slide extends Action { private Vector3d slidingVec = null; @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { Vector3d lookingVec = player.getLookAngle().multiply(1, 0, 1).normalize(); startInfo.putDouble(lookingVec.x()).putDouble(lookingVec.z()); return (!stamina.isExhausted() @@ -47,7 +47,7 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { int maxSlidingTick = Math.min( parkourability.getActionInfo().getClientSetting().get(ParCoolConfig.Client.Integers.SlidingContinuableTick), parkourability.getActionInfo().getServerLimitation().get(ParCoolConfig.Server.Integers.MaxSlidingContinuableTick) @@ -57,7 +57,7 @@ public boolean canContinue(PlayerEntity player, Parkourability parkourability, I } @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { slidingVec = new Vector3d(startData.getDouble(), 0, startData.getDouble()); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.SLIDE.get(), 1f, 1f); @@ -69,7 +69,7 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { slidingVec = new Vector3d(startData.getDouble(), 0, startData.getDouble()); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.SLIDE.get(), 1f, 1f); @@ -80,7 +80,7 @@ public void onStartInOtherClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onWorkingTickInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (slidingVec != null) { ModifiableAttributeInstance attr = player.getAttribute(Attributes.MOVEMENT_SPEED); double speedScale = 0.45; @@ -93,12 +93,12 @@ public void onWorkingTickInLocalClient(PlayerEntity player, Parkourability parko } @Override - public void onWorkingTickInClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { spawnSlidingParticle(player); } @Override - public void onStopInLocalClient(PlayerEntity player) { + public void onStopInLocalClient(PlayerWrapper player) { Animation animation = Animation.get(player); if (animation != null && !animation.hasAnimator()) { animation.setAnimator(new CrawlAnimator()); @@ -106,7 +106,7 @@ public void onStopInLocalClient(PlayerEntity player) { } @Override - public void onStopInOtherClient(PlayerEntity player) { + public void onStopInOtherClient(PlayerWrapper player) { Animation animation = Animation.get(player); if (animation != null && !animation.hasAnimator()) { animation.setAnimator(new CrawlAnimator()); @@ -124,11 +124,11 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { } @OnlyIn(Dist.CLIENT) - private void spawnSlidingParticle(PlayerEntity player) { + private void spawnSlidingParticle(PlayerWrapper player) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; - World level = player.level; + World level = player.getLevel(); Vector3d pos = player.position(); - BlockState feetBlock = player.level.getBlockState(player.blockPosition().below()); + BlockState feetBlock = player.getBelowBlockState(); float width = player.getBbWidth(); Vector3d direction = getSlidingVector(); if (direction == null) return; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Tap.java b/src/main/java/com/alrex/parcool/common/action/impl/Tap.java index a1b03b51..41f73b3e 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Tap.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Tap.java @@ -1,5 +1,6 @@ package com.alrex.parcool.common.action.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.TapAnimator; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.BehaviorEnforcer; @@ -7,7 +8,6 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; -import net.minecraft.entity.player.PlayerEntity; import java.nio.ByteBuffer; @@ -16,8 +16,8 @@ public class Tap extends Action { private boolean startRequired = false; @Override - public void onWorkingTickInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { - player.setDeltaMovement(player.getDeltaMovement().multiply(0.01, 1, 0.01)); + public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { + player.multiplyDeltaMovement(0.01, 1, 0.01); } @Override @@ -26,7 +26,7 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { } @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { startRequired = false; Animation animation = Animation.get(player); if (animation != null) animation.setAnimator(new TapAnimator()); @@ -34,23 +34,23 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { startRequired = false; Animation animation = Animation.get(player); if (animation != null) animation.setAnimator(new TapAnimator()); } @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { return startRequired; } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return getDoingTick() < getMaxTappingTick(); } - public void startTap(PlayerEntity player) { + public void startTap(PlayerWrapper player) { startRequired = true; } diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Vault.java b/src/main/java/com/alrex/parcool/common/action/impl/Vault.java index 86df4e7c..b2ae39be 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Vault.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Vault.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.KongVaultAnimator; import com.alrex.parcool.client.animation.impl.SpeedVaultAnimator; import com.alrex.parcool.client.input.KeyBindings; @@ -11,7 +12,6 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.WorldUtil; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -43,7 +43,7 @@ public AnimationType getCurrentAnimation() { @OnlyIn(Dist.CLIENT) @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { Vector3d lookVec = player.getLookAngle(); lookVec = new Vector3d(lookVec.x(), 0, lookVec.z()).normalize(); Vector3d step = WorldUtil.getVaultableStep(player); @@ -92,7 +92,7 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return getDoingTick() < MAX_TICK; } @@ -102,7 +102,7 @@ private int getVaultAnimateTime() { @OnlyIn(Dist.CLIENT) @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { currentAnimation = AnimationType.values()[startData.get()]; if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.VAULT.get(), 1f, 1f); @@ -126,7 +126,7 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil @OnlyIn(Dist.CLIENT) @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { currentAnimation = AnimationType.values()[startData.get()]; if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.VAULT.get(), 1f, 1f); @@ -148,7 +148,7 @@ public void onStartInOtherClient(PlayerEntity player, Parkourability parkourabil @OnlyIn(Dist.CLIENT) @Override - public void onWorkingTickInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (stepDirection == null) return; if (getDoingTick() < getVaultAnimateTime()) { player.setDeltaMovement( @@ -173,7 +173,7 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { @OnlyIn(Dist.CLIENT) @Override - public void onStopInLocalClient(PlayerEntity player) { + public void onStopInLocalClient(PlayerWrapper player) { } } diff --git a/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java b/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java index bd32d740..e98fc8af 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.VerticalWallRunAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; @@ -13,7 +14,6 @@ import com.alrex.parcool.utilities.WorldUtil; import net.minecraft.block.BlockRenderType; import net.minecraft.block.BlockState; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; @@ -30,12 +30,12 @@ public class VerticalWallRun extends Action { private Vector3d wallDirection = null; @Override - public void onTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { playerYSpeed = player.getDeltaMovement().y(); } @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { int tickAfterJump = parkourability.getAdditionalProperties().getTickAfterLastJump(); Vector3d lookVec = player.getLookAngle(); boolean able = !stamina.isExhausted() @@ -66,8 +66,8 @@ && getNotDoingTick() > 15 player.getBoundingBox().minY + player.getBbHeight() * 0.5, player.getZ() + wall.z() ); - if (!player.level.isLoaded(targetBlock)) return false; - float slipperiness = player.level.getBlockState(targetBlock).getSlipperiness(player.level, targetBlock, player); + if (!player.isEveryLoaded(targetBlock)) return false; + float slipperiness = player.getSlipperiness(targetBlock); startInfo.putDouble(height); startInfo.putFloat(slipperiness); startInfo.putDouble(wall.x()); @@ -81,7 +81,7 @@ && getNotDoingTick() > 15 } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { Vector3d wall = WorldUtil.getWall(player); if (wall == null) return false; wall = wall.normalize(); @@ -91,7 +91,7 @@ public boolean canContinue(PlayerEntity player, Parkourability parkourability, I } @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { double height = startData.getDouble(); float slipperiness = startData.getFloat(); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) @@ -105,7 +105,7 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { startData.position(8 + 4); // skip (double * 1) and (float * 1) wallDirection = new Vector3d(startData.getDouble(), startData.getDouble(), startData.getDouble()); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) @@ -117,15 +117,15 @@ public void onStartInOtherClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onRenderTick(TickEvent.RenderTickEvent event, PlayerEntity player, Parkourability parkourability) { + public void onRenderTick(TickEvent.RenderTickEvent event, PlayerWrapper player, Parkourability parkourability) { if (wallDirection != null && isDoing()) { - player.setYHeadRot((float) VectorUtil.toYawDegree(wallDirection)); - player.yBodyRotO = player.yBodyRot = player.getYHeadRot(); + player.setYHeadRot((float)VectorUtil.toYawDegree(wallDirection)); + player.setAllYBodyRot(player.getYHeadRot()); } } @Override - public void onWorkingTickInClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { spawnRunningParticle(player); } @@ -135,10 +135,10 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { } @OnlyIn(Dist.CLIENT) - public void spawnRunningParticle(PlayerEntity player) { + public void spawnRunningParticle(PlayerWrapper player) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; if (wallDirection == null) return; - World level = player.level; + World level = player.getLevel(); Vector3d pos = player.position(); BlockPos leanedBlock = new BlockPos( pos.add(wallDirection.x(), player.getBbHeight() * 0.25, wallDirection.z()) diff --git a/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java b/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java index 5cc13053..1e14efcb 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.BackwardWallJumpAnimator; import com.alrex.parcool.client.animation.impl.WallJumpAnimator; import com.alrex.parcool.client.input.KeyRecorder; @@ -13,7 +14,6 @@ import com.alrex.parcool.utilities.WorldUtil; import net.minecraft.block.BlockRenderType; import net.minecraft.block.BlockState; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; @@ -44,7 +44,7 @@ private boolean isInCooldown(Parkourability parkourability) { && getNotDoingTick() <= MAX_COOL_DOWN_TICK; } @Override - public void onTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { jump = false; } @@ -56,7 +56,7 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { @OnlyIn(Dist.CLIENT) @Nullable - private Vector3d getJumpDirection(PlayerEntity player, Vector3d wall) { + private Vector3d getJumpDirection(PlayerWrapper player, Vector3d wall) { if (wall == null) return null; wall = wall.normalize(); Vector3d lookVec = player.getLookAngle(); @@ -78,7 +78,7 @@ private Vector3d getJumpDirection(PlayerEntity player, Vector3d wall) { } @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { Vector3d wallDirection = WorldUtil.getWall(player, player.getBbWidth() * 0.65); Vector3d jumpDirection = getJumpDirection(player, wallDirection); if (jumpDirection == null) return false; @@ -89,7 +89,7 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta && !player.isOnGround() && !player.isInWaterOrBubble() && !player.isFallFlying() - && !player.abilities.flying + && !player.isFlying() && parkourability.getAdditionalProperties().getNotCreativeFlyingTick() > 10 && ((!cling.isDoing() && cling.getNotDoingTick() > 3) || (cling.isDoing() && cling.getFacingDirection() != ClingToCliff.FacingDirection.ToWall)) @@ -140,18 +140,18 @@ public boolean canStart(PlayerEntity player, Parkourability parkourability, ISta } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { return false; } @Override - public void onStart(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStart(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { jump = true; - player.fallDistance = 0; + player.resetFallDistance(); } @Override - public void onStartInLocalClient(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { + public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.WALL_JUMP.get(), 1f, 1f); Vector3d jumpDirection = new Vector3d(startData.getDouble(), startData.getDouble(), startData.getDouble()); @@ -164,8 +164,8 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil player.getBoundingBox().minY + player.getBbHeight() * 0.25, player.getZ() + wallDirection.z() ); - float slipperiness = player.level.isLoaded(leanedBlock) ? - player.level.getBlockState(leanedBlock).getSlipperiness(player.level, leanedBlock, player) + float slipperiness = player.isEveryLoaded(leanedBlock) ? + player.getSlipperiness(leanedBlock) : 0.6f; double ySpeed; @@ -198,7 +198,7 @@ public void onStartInLocalClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onStartInOtherClient(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.WALL_JUMP.get(), 1f, 1f); Vector3d jumpDirection = new Vector3d(startData.getDouble(), startData.getDouble(), startData.getDouble()); @@ -208,8 +208,8 @@ public void onStartInOtherClient(PlayerEntity player, Parkourability parkourabil player.getBoundingBox().minY + player.getBbHeight() * 0.25, player.getZ() + wallDirection.z() ); - float slipperiness = player.level.isLoaded(leanedBlock) ? - player.level.getBlockState(leanedBlock).getSlipperiness(player.level, leanedBlock, player) + float slipperiness = player.isEveryLoaded(leanedBlock) ? + player.getSlipperiness(leanedBlock) : 1f; if (slipperiness <= 0.9) {// icy blocks spawnJumpParticles(player, wallDirection, jumpDirection); @@ -232,14 +232,14 @@ public void onStartInOtherClient(PlayerEntity player, Parkourability parkourabil } @Override - public void onWorkingTickInClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { super.onWorkingTickInClient(player, parkourability, stamina); } @OnlyIn(Dist.CLIENT) - private void spawnJumpParticles(PlayerEntity player, Vector3d wallDirection, Vector3d jumpDirection) { + private void spawnJumpParticles(PlayerWrapper player, Vector3d wallDirection, Vector3d jumpDirection) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; - World level = player.level; + World level = player.getLevel(); Vector3d pos = player.position(); BlockPos leanedBlock = new BlockPos( pos.add(wallDirection.x(), player.getBbHeight() * 0.25, wallDirection.z()) diff --git a/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java b/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java index 2e7007d7..882e95ad 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java @@ -1,5 +1,6 @@ package com.alrex.parcool.common.action.impl; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.WallSlideAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; @@ -12,7 +13,6 @@ import com.alrex.parcool.utilities.WorldUtil; import net.minecraft.block.BlockRenderType; import net.minecraft.block.BlockState; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; @@ -38,19 +38,19 @@ public Vector3d getLeanedWallDirection() { @OnlyIn(Dist.CLIENT) @Override - public boolean canStart(PlayerEntity player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { + public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { startInfo.putDouble(Math.abs(player.getDeltaMovement().y())); return canContinue(player, parkourability, stamina); } @Override - public boolean canContinue(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { Vector3d wall = WorldUtil.getWall(player); return (wall != null && !player.isOnGround() && !parkourability.get(FastRun.class).isDoing() && !parkourability.get(Dodge.class).isDoing() - && !player.abilities.flying + && !player.isFlying() && player.getDeltaMovement().y() <= 0 && KeyBindings.getKeyWallSlide().isDown() && !stamina.isExhausted() @@ -61,12 +61,12 @@ public boolean canContinue(PlayerEntity player, Parkourability parkourability, I } @Override - public void onStart(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStart(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { particleSpawnCoolTime = 0; } @Override - public void onStartInServer(PlayerEntity player, Parkourability parkourability, ByteBuffer startData) { + public void onStartInServer(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { startYSpeed = startData.getDouble(); damageCount = (int) (5.5 * (startYSpeed - 1.) / player.getBbHeight()); takenDamageCount = 0; @@ -75,7 +75,7 @@ public void onStartInServer(PlayerEntity player, Parkourability parkourability, @OnlyIn(Dist.CLIENT) @Override - public void onWorkingTickInClient(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { Animation animation = Animation.get(player); if (animation != null && !animation.hasAnimator()) { animation.setAnimator(new WallSlideAnimator()); @@ -93,7 +93,7 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { } @Override - public void onWorkingTick(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { leanedWallDirection = WorldUtil.getWall(player); if (leanedWallDirection != null) { BlockPos leanedBlock = new BlockPos( @@ -101,33 +101,30 @@ public void onWorkingTick(PlayerEntity player, Parkourability parkourability, IS player.getBoundingBox().minY + player.getBbHeight() * 0.75, player.getZ() + leanedWallDirection.z() ); - if (!player.level.isLoaded(leanedBlock)) return; - float slipperiness = player.level.getBlockState(leanedBlock).getSlipperiness(player.level, leanedBlock, player); + if (!player.isEveryLoaded(leanedBlock)) return; + float slipperiness = player.getSlipperiness(leanedBlock); slipperiness = (float) Math.sqrt(slipperiness); - player.fallDistance *= slipperiness; + player.multiplyFallDistance(slipperiness); player.setDeltaMovement(player.getDeltaMovement().multiply(0.8, slipperiness, 0.8)); } } @Override - public void onWorkingTickInServer(PlayerEntity player, Parkourability parkourability, IStamina stamina) { + public void onWorkingTickInServer(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (damageCoolTime <= 0 && damageCount > takenDamageCount++) { - int invulnerableTime = player.invulnerableTime; // bypass invulnerableTime damageCoolTime = 1; - player.invulnerableTime = 0; - player.hurt(DamageSources.WALL_SLIDE, 0.3f); - player.invulnerableTime = invulnerableTime; + player.forceDamage(DamageSources.WALL_SLIDE, 0.3f); } else { damageCoolTime--; } } @OnlyIn(Dist.CLIENT) - private void spawnSlideParticle(PlayerEntity player) { + private void spawnSlideParticle(PlayerWrapper player) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; if (leanedWallDirection == null) return; if (player.getRandom().nextBoolean()) return; - World level = player.level; + World level = player.getLevel(); Vector3d pos = player.position(); BlockPos leanedBlock = new BlockPos( pos.add(leanedWallDirection.x(), player.getBbHeight() * 0.25, leanedWallDirection.z()) diff --git a/src/main/java/com/alrex/parcool/common/block/zipline/IronZiplineHookBlock.java b/src/main/java/com/alrex/parcool/common/block/zipline/IronZiplineHookBlock.java index 58dd9ff7..744d480b 100644 --- a/src/main/java/com/alrex/parcool/common/block/zipline/IronZiplineHookBlock.java +++ b/src/main/java/com/alrex/parcool/common/block/zipline/IronZiplineHookBlock.java @@ -1,9 +1,9 @@ package com.alrex.parcool.common.block.zipline; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.block.BlockStateProperties; import net.minecraft.block.Block; import net.minecraft.block.BlockState; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.item.BlockItemUseContext; import net.minecraft.state.BooleanProperty; import net.minecraft.state.StateContainer; @@ -70,7 +70,7 @@ public BlockState getStateForPlacement(BlockItemUseContext context) { BlockState state = super.getStateForPlacement(context); boolean orthogonal; - PlayerEntity player = context.getPlayer(); + PlayerWrapper player = PlayerWrapper.get(context); if (player == null) orthogonal = false; else { diff --git a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java index 7bff9777..52561665 100644 --- a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java +++ b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.block.zipline; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.block.TileEntities; import net.minecraft.block.Block; import net.minecraft.block.BlockState; @@ -89,7 +90,8 @@ public boolean isPathfindable(BlockState p_196266_1_, IBlockReader p_196266_2_, } @Override - public ActionResultType use(BlockState blockState, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockRayTraceResult blockRayTraceResult) { + public ActionResultType use(BlockState blockState, World world, BlockPos pos, PlayerEntity playerEntity, Hand hand, BlockRayTraceResult blockRayTraceResult) { + PlayerWrapper player = PlayerWrapper.get(playerEntity); ItemStack stack = player.getItemInHand(hand); if (stack.getItem() instanceof ShearsItem) { TileEntity tileEntity = world.getBlockEntity(pos); @@ -103,11 +105,8 @@ public ActionResultType use(BlockState blockState, World world, BlockPos pos, Pl return ActionResultType.SUCCESS; } else { itemStacks.forEach((it) -> InventoryHelper.dropItemStack(world, pos.getX(), pos.getY(), pos.getZ(), it)); - if (!itemStacks.isEmpty()) { - if (stack.isDamageableItem()) { - stack.hurtAndBreak(1, player, (it) -> { - }); - } + if (!itemStacks.isEmpty() && stack.isDamageableItem()) { + player.hurtAndBreakStack(1, stack); } return ActionResultType.CONSUME; } @@ -127,5 +126,4 @@ public boolean hasTileEntity(BlockState state) { public TileEntity createTileEntity(BlockState state, IBlockReader world) { return new ZiplineHookTileEntity(TileEntities.ZIPLINE_HOOK.get()); } - } diff --git a/src/main/java/com/alrex/parcool/common/capability/Animation.java b/src/main/java/com/alrex/parcool/common/capability/Animation.java index b003e517..96c07c5e 100644 --- a/src/main/java/com/alrex/parcool/common/capability/Animation.java +++ b/src/main/java/com/alrex/parcool/common/capability/Animation.java @@ -1,5 +1,8 @@ package com.alrex.parcool.common.capability; +import com.alrex.parcool.api.compatibility.AbstractClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.unstable.animation.AnimationOption; import com.alrex.parcool.api.unstable.animation.AnimationPart; import com.alrex.parcool.api.unstable.animation.ParCoolAnimationInfoEvent; @@ -10,9 +13,6 @@ import com.alrex.parcool.common.capability.capabilities.Capabilities; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.client.Minecraft; -import net.minecraft.client.entity.player.AbstractClientPlayerEntity; -import net.minecraft.client.entity.player.ClientPlayerEntity; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.client.event.EntityViewRenderEvent; @@ -22,7 +22,7 @@ @OnlyIn(Dist.CLIENT) public class Animation { - public static Animation get(PlayerEntity player) { + public static Animation get(PlayerWrapper player) { LazyOptional optional = player.getCapability(Capabilities.ANIMATION_CAPABILITY); if (!optional.isPresent()) return null; return optional.orElseThrow(IllegalStateException::new); @@ -38,7 +38,7 @@ public void setAnimator(Animator animator) { this.animator = animator; } - public boolean animatePre(PlayerEntity player, PlayerModelTransformer modelTransformer) { + public boolean animatePre(PlayerWrapper player, PlayerModelTransformer modelTransformer) { Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return false; if (animator != null && animator.shouldRemoved(player, parkourability)) animator = null; @@ -48,7 +48,7 @@ public boolean animatePre(PlayerEntity player, PlayerModelTransformer modelTrans return animator.animatePre(player, parkourability, modelTransformer); } - public void animatePost(PlayerEntity player, PlayerModelTransformer modelTransformer) { + public void animatePost(PlayerWrapper player, PlayerModelTransformer modelTransformer) { Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; if (animator == null) { @@ -59,7 +59,7 @@ public void animatePost(PlayerEntity player, PlayerModelTransformer modelTransfo animator.animatePost(player, parkourability, modelTransformer); } - public boolean rotatePre(AbstractClientPlayerEntity player, PlayerModelRotator rotator) { + public boolean rotatePre(AbstractClientPlayerWrapper player, PlayerModelRotator rotator) { Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return false; if (animator != null && animator.shouldRemoved(player, parkourability)) animator = null; @@ -68,7 +68,7 @@ public boolean rotatePre(AbstractClientPlayerEntity player, PlayerModelRotator r return animator.rotatePre(player, parkourability, rotator); } - public void rotatePost(AbstractClientPlayerEntity player, PlayerModelRotator rotator) { +public void rotatePost(AbstractClientPlayerWrapper player, PlayerModelRotator rotator) { Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; if (animator == null) { @@ -79,7 +79,7 @@ public void rotatePost(AbstractClientPlayerEntity player, PlayerModelRotator rot animator.rotatePost(player, parkourability, rotator); } - public void cameraSetup(EntityViewRenderEvent.CameraSetup event, ClientPlayerEntity player, Parkourability parkourability) { + public void cameraSetup(EntityViewRenderEvent.CameraSetup event, ClientPlayerWrapper player, Parkourability parkourability) { if (animator == null) return; if (player.isLocalPlayer() && Minecraft.getInstance().options.getCameraType().isFirstPerson() @@ -89,7 +89,7 @@ public void cameraSetup(EntityViewRenderEvent.CameraSetup event, ClientPlayerEnt animator.onCameraSetUp(event, player, parkourability); } - public void tick(AbstractClientPlayerEntity player, Parkourability parkourability) { + public void tick(AbstractClientPlayerWrapper player, Parkourability parkourability) { passiveAnimation.tick(player, parkourability); if (animator != null) { animator.tick(player); @@ -101,7 +101,7 @@ public void tick(AbstractClientPlayerEntity player, Parkourability parkourabilit } } - public void onRenderTick(TickEvent.RenderTickEvent event, PlayerEntity player, Parkourability parkourability) { + public void onRenderTick(TickEvent.RenderTickEvent event, PlayerWrapper player, Parkourability parkourability) { if (animator != null) { animator.onRenderTick(event, player, parkourability); } diff --git a/src/main/java/com/alrex/parcool/common/capability/IStamina.java b/src/main/java/com/alrex/parcool/common/capability/IStamina.java index 8a0f770f..6c3e2ae0 100644 --- a/src/main/java/com/alrex/parcool/common/capability/IStamina.java +++ b/src/main/java/com/alrex/parcool/common/capability/IStamina.java @@ -1,10 +1,10 @@ package com.alrex.parcool.common.capability; +import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.capabilities.Capabilities; import com.alrex.parcool.common.capability.stamina.HungerStamina; import com.alrex.parcool.common.capability.stamina.Stamina; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraftforge.common.util.LazyOptional; import javax.annotation.Nullable; @@ -16,22 +16,22 @@ public enum Type { Default(Stamina.class, Stamina::new, null), Hunger(HungerStamina.class, HungerStamina::new, HungerStamina::consumeOnServer); - Type(Class clazz, Function constructor, BiConsumer serverStaminaHandler) { + Type(Class clazz, Function constructor, BiConsumer serverStaminaHandler) { this.constructor = constructor; this.clazz = clazz; this.serverStaminaHandler = serverStaminaHandler; } - private final Function constructor; + private final Function constructor; private final Class clazz; @Nullable - private final BiConsumer serverStaminaHandler; + private final BiConsumer serverStaminaHandler; - public IStamina newInstance(PlayerEntity player) { + public IStamina newInstance(PlayerWrapper player) { return constructor.apply(player); } - public void handleConsumeOnServer(ServerPlayerEntity player, int value) { + public void handleConsumeOnServer(ServerPlayerWrapper player, int value) { if (this.serverStaminaHandler != null) { serverStaminaHandler.accept(player, value); } @@ -47,7 +47,7 @@ public static Type getFromInstance(IStamina stamina) { } } @Nullable - public static IStamina get(PlayerEntity player) { + public static IStamina get(PlayerWrapper player) { LazyOptional optional = player.getCapability(Capabilities.STAMINA_CAPABILITY); return optional.orElse(null); } diff --git a/src/main/java/com/alrex/parcool/common/capability/Parkourability.java b/src/main/java/com/alrex/parcool/common/capability/Parkourability.java index 717715ab..1ab1bfdc 100644 --- a/src/main/java/com/alrex/parcool/common/capability/Parkourability.java +++ b/src/main/java/com/alrex/parcool/common/capability/Parkourability.java @@ -1,5 +1,7 @@ package com.alrex.parcool.common.capability; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.ActionList; import com.alrex.parcool.common.action.AdditionalProperties; @@ -9,8 +11,6 @@ import com.alrex.parcool.common.info.ClientSetting; import com.alrex.parcool.common.info.ServerLimitation; import com.alrex.parcool.common.network.SyncClientInformationMessage; -import net.minecraft.client.entity.player.ClientPlayerEntity; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.common.util.LazyOptional; @@ -21,7 +21,7 @@ public class Parkourability { @Nullable - public static Parkourability get(PlayerEntity player) { + public static Parkourability get(PlayerWrapper player) { LazyOptional optional = player.getCapability(Capabilities.PARKOURABILITY_CAPABILITY); return optional.orElse(null); } @@ -95,7 +95,7 @@ public boolean isDoingNothing() { } @OnlyIn(Dist.CLIENT) - public void trySyncLimitation(ClientPlayerEntity player) { + public void trySyncLimitation(ClientPlayerWrapper player) { synchronizeTrialCount++; SyncClientInformationMessage.sync(player, true); } diff --git a/src/main/java/com/alrex/parcool/common/capability/stamina/HungerStamina.java b/src/main/java/com/alrex/parcool/common/capability/stamina/HungerStamina.java index 9094bac3..04adde5c 100644 --- a/src/main/java/com/alrex/parcool/common/capability/stamina/HungerStamina.java +++ b/src/main/java/com/alrex/parcool/common/capability/stamina/HungerStamina.java @@ -1,16 +1,16 @@ package com.alrex.parcool.common.capability.stamina; import com.alrex.parcool.api.Effects; +import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.entity.player.ServerPlayerEntity; public class HungerStamina implements IStamina { - private final PlayerEntity player; + private final PlayerWrapper player; private float consumedBuffer = 0; - public HungerStamina(PlayerEntity player) { + public HungerStamina(PlayerWrapper player) { this.player = player; } @@ -21,7 +21,7 @@ public int getActualMaxStamina() { @Override public int get() { - return player.getFoodData().getFoodLevel(); + return player.getFoodLevel(); } @Override @@ -34,7 +34,7 @@ public void consume(int value) { Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; if (isExhausted() - || parkourability.getActionInfo().isStaminaInfinite(player.isSpectator() || player.isCreative()) + || parkourability.getActionInfo().isStaminaInfinite(player.isImmortal()) || player.hasEffect(Effects.INEXHAUSTIBLE.get()) ) return; consumedBuffer += value / 150f; @@ -73,7 +73,7 @@ public int getRequestedValueConsumedOnServer() { return neededValue; } - public static void consumeOnServer(ServerPlayerEntity player, int value) { + public static void consumeOnServer(ServerPlayerWrapper player, int value) { player.causeFoodExhaustion(value / 10000f); } } diff --git a/src/main/java/com/alrex/parcool/common/capability/stamina/OtherStamina.java b/src/main/java/com/alrex/parcool/common/capability/stamina/OtherStamina.java index 67db7c51..c3b4f54c 100644 --- a/src/main/java/com/alrex/parcool/common/capability/stamina/OtherStamina.java +++ b/src/main/java/com/alrex/parcool/common/capability/stamina/OtherStamina.java @@ -1,20 +1,20 @@ package com.alrex.parcool.common.capability.stamina; +import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.IStamina; import net.minecraft.entity.ai.attributes.AttributeModifier; import net.minecraft.entity.ai.attributes.Attributes; import net.minecraft.entity.ai.attributes.ModifiableAttributeInstance; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.entity.player.ServerPlayerEntity; import java.util.UUID; public class OtherStamina implements IStamina { private static final String EXHAUSTED_SPEED_MODIFIER_NAME = "parcool.modifier.exhausted.speed"; private static final UUID EXHAUSTED_SPEED_MODIFIER_UUID = UUID.randomUUID(); - private final PlayerEntity player; + private final PlayerWrapper player; - public OtherStamina(PlayerEntity player) { + public OtherStamina(PlayerWrapper player) { this.player = player; } @@ -61,7 +61,7 @@ public void setExhaustion(boolean value) { @Override public void tick() { - if (player instanceof ServerPlayerEntity) { + if (ServerPlayerWrapper.is(player)) { ModifiableAttributeInstance attr = player.getAttribute(Attributes.MOVEMENT_SPEED); if (attr == null) return; if (attr.getModifier(EXHAUSTED_SPEED_MODIFIER_UUID) != null) diff --git a/src/main/java/com/alrex/parcool/common/capability/stamina/Stamina.java b/src/main/java/com/alrex/parcool/common/capability/stamina/Stamina.java index 0269d411..d935309d 100644 --- a/src/main/java/com/alrex/parcool/common/capability/stamina/Stamina.java +++ b/src/main/java/com/alrex/parcool/common/capability/stamina/Stamina.java @@ -2,15 +2,15 @@ import com.alrex.parcool.api.Attributes; import com.alrex.parcool.api.Effects; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import net.minecraft.entity.ai.attributes.ModifiableAttributeInstance; -import net.minecraft.entity.player.PlayerEntity; import javax.annotation.Nullable; public class Stamina implements IStamina { - public Stamina(@Nullable PlayerEntity player) { + public Stamina(@Nullable PlayerWrapper player) { this.player = player; if (player != null && player.isLocalPlayer()) { set(Integer.MAX_VALUE); @@ -22,7 +22,7 @@ public Stamina() { } @Nullable - private final PlayerEntity player; + private final PlayerWrapper player; private int stamina = 0; private int staminaOld = 0; @@ -54,7 +54,7 @@ public void consume(int value) { Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; if (exhausted - || parkourability.getActionInfo().isStaminaInfinite(player.isSpectator() || player.isCreative()) + || parkourability.getActionInfo().isStaminaInfinite(player.isImmortal()) || player.hasEffect(Effects.INEXHAUSTIBLE.get()) ) return; recoverCoolTime = 30; diff --git a/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java b/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java index 116bd50f..cd8f1227 100644 --- a/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java +++ b/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java @@ -1,5 +1,6 @@ package com.alrex.parcool.common.entity.zipline; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.block.zipline.ZiplineHookTileEntity; import com.alrex.parcool.common.block.zipline.ZiplineInfo; import com.alrex.parcool.common.item.zipline.ZiplineRopeItem; @@ -174,7 +175,7 @@ private void setZiplineType(ZiplineType type) { @Nonnull @Override public ActionResultType interact(PlayerEntity p_184230_1_, Hand p_184230_2_) { - return ActionResultType.sidedSuccess(p_184230_1_.level.isClientSide()); + return ActionResultType.sidedSuccess(PlayerWrapper.get(p_184230_1_).isLevelClientSide()); } @Override diff --git a/src/main/java/com/alrex/parcool/common/handlers/AttachCapabilityHandler.java b/src/main/java/com/alrex/parcool/common/handlers/AttachCapabilityHandler.java index 002f8966..dd1aad5d 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/AttachCapabilityHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/AttachCapabilityHandler.java @@ -1,5 +1,6 @@ package com.alrex.parcool.common.handlers; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; @@ -7,7 +8,6 @@ import com.alrex.parcool.common.capability.stamina.OtherStamina; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.entity.Entity; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.nbt.CompoundNBT; import net.minecraft.util.Direction; import net.minecraftforge.common.capabilities.Capability; @@ -16,7 +16,6 @@ import net.minecraftforge.common.util.LazyOptional; import net.minecraftforge.event.AttachCapabilitiesEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; - import javax.annotation.Nonnull; import javax.annotation.Nullable; @@ -24,8 +23,8 @@ public class AttachCapabilityHandler { @SubscribeEvent public static void onAttachCapability(AttachCapabilitiesEvent event) { - if (!(event.getObject() instanceof PlayerEntity)) return; - PlayerEntity player = (PlayerEntity) event.getObject(); + PlayerWrapper player = PlayerWrapper.getOrDefault(event); + if (player == null) return; //Parkourability { Parkourability instance = new Parkourability(); diff --git a/src/main/java/com/alrex/parcool/common/handlers/EnableOrDisableParCoolHandler.java b/src/main/java/com/alrex/parcool/common/handlers/EnableOrDisableParCoolHandler.java index edf7e366..bf9b036a 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/EnableOrDisableParCoolHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/EnableOrDisableParCoolHandler.java @@ -2,13 +2,12 @@ import com.alrex.parcool.ParCool; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ClientSetting; import com.alrex.parcool.common.network.SyncClientInformationMessage; import com.alrex.parcool.config.ParCoolConfig; -import net.minecraft.client.Minecraft; -import net.minecraft.client.entity.player.ClientPlayerEntity; import net.minecraft.util.text.TranslationTextComponent; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -24,7 +23,7 @@ public static void onTick(TickEvent.ClientTickEvent event) { if (KeyBindings.getKeyBindEnable().consumeClick()) { ParCoolConfig.Client.Booleans.ParCoolIsActive.set(!ParCoolConfig.Client.Booleans.ParCoolIsActive.get()); boolean currentStatus = ParCool.isActive(); - ClientPlayerEntity player = Minecraft.getInstance().player; + ClientPlayerWrapper player = ClientPlayerWrapper.get(); if (player == null) return; Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; diff --git a/src/main/java/com/alrex/parcool/common/handlers/InputHandler.java b/src/main/java/com/alrex/parcool/common/handlers/InputHandler.java index a138d2ce..2c1d6af1 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/InputHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/InputHandler.java @@ -1,20 +1,19 @@ package com.alrex.parcool.common.handlers; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.impl.ClingToCliff; import com.alrex.parcool.common.action.impl.HideInBlock; import com.alrex.parcool.common.action.impl.RideZipline; import com.alrex.parcool.common.action.impl.WallSlide; import com.alrex.parcool.common.capability.Parkourability; -import net.minecraft.client.Minecraft; -import net.minecraft.client.entity.player.ClientPlayerEntity; import net.minecraftforge.client.event.InputEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; public class InputHandler { @SubscribeEvent public static void onInput(InputEvent.ClickInputEvent event) { - ClientPlayerEntity player = Minecraft.getInstance().player; + ClientPlayerWrapper player = ClientPlayerWrapper.get(); if (player == null) return; Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; diff --git a/src/main/java/com/alrex/parcool/common/handlers/LoginLogoutHandler.java b/src/main/java/com/alrex/parcool/common/handlers/LoginLogoutHandler.java index 09999163..6e6e17c7 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/LoginLogoutHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/LoginLogoutHandler.java @@ -1,19 +1,19 @@ package com.alrex.parcool.common.handlers; +import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.server.limitation.Limitations; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraftforge.event.entity.player.PlayerEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; public class LoginLogoutHandler { @SubscribeEvent public static void onLogout(PlayerEvent.PlayerLoggedOutEvent event) { - PlayerEntity player = event.getPlayer(); + PlayerWrapper player = PlayerWrapper.get(event); Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; - if (player instanceof ServerPlayerEntity) { + if (ServerPlayerWrapper.is(player)) { Limitations.unload(player.getUUID()); } } diff --git a/src/main/java/com/alrex/parcool/common/handlers/OpenSettingsParCoolHandler.java b/src/main/java/com/alrex/parcool/common/handlers/OpenSettingsParCoolHandler.java index 37e76fea..97967eef 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/OpenSettingsParCoolHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/OpenSettingsParCoolHandler.java @@ -1,11 +1,11 @@ package com.alrex.parcool.common.handlers; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.client.gui.SettingActionLimitationScreen; import com.alrex.parcool.client.input.KeyRecorder; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.client.Minecraft; -import net.minecraft.client.entity.player.ClientPlayerEntity; import net.minecraft.util.text.StringTextComponent; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -19,7 +19,7 @@ public static void onTick(TickEvent.ClientTickEvent event) { if (event.phase == TickEvent.Phase.END) return; if (KeyRecorder.keyOpenSettingsState.isPressed()) { - ClientPlayerEntity player = Minecraft.getInstance().player; + ClientPlayerWrapper player = ClientPlayerWrapper.get(); if (player == null) return; Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; diff --git a/src/main/java/com/alrex/parcool/common/handlers/PlayerCloneHandler.java b/src/main/java/com/alrex/parcool/common/handlers/PlayerCloneHandler.java index 083f5691..25a16fdc 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/PlayerCloneHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/PlayerCloneHandler.java @@ -1,23 +1,21 @@ package com.alrex.parcool.common.handlers; +import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraftforge.event.entity.player.PlayerEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; public class PlayerCloneHandler { @SubscribeEvent public static void onClone(PlayerEvent.Clone event) { - PlayerEntity player = event.getPlayer(); - if (event.isWasDeath() && player instanceof ServerPlayerEntity) { - PlayerEntity from = event.getOriginal(); - PlayerEntity to = event.getPlayer(); - Parkourability pFrom = Parkourability.get(from); - Parkourability pTo = Parkourability.get(to); - if (pFrom != null && pTo != null) { - pTo.CopyFrom(pFrom); - } + if (!event.isWasDeath() || ServerPlayerWrapper.getOrDefault(event) == null) return; + PlayerWrapper from = PlayerWrapper.getOriginalPlayer(event); + PlayerWrapper to = PlayerWrapper.get(event); + Parkourability pFrom = Parkourability.get(from); + Parkourability pTo = Parkourability.get(to); + if (pFrom != null && pTo != null) { + pTo.CopyFrom(pFrom); } } } diff --git a/src/main/java/com/alrex/parcool/common/handlers/PlayerDamageHandler.java b/src/main/java/com/alrex/parcool/common/handlers/PlayerDamageHandler.java index 4370ce2f..5d7e38cd 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/PlayerDamageHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/PlayerDamageHandler.java @@ -1,12 +1,12 @@ package com.alrex.parcool.common.handlers; +import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.action.impl.*; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.network.StartBreakfallMessage; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.entity.LivingEntity; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraftforge.event.entity.living.LivingAttackEvent; import net.minecraftforge.event.entity.living.LivingFallEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; @@ -15,27 +15,26 @@ public class PlayerDamageHandler { @SubscribeEvent public static void onAttack(LivingAttackEvent event) { LivingEntity entity = event.getEntityLiving(); - if (entity instanceof PlayerEntity) { - PlayerEntity player = (PlayerEntity) entity; - Parkourability parkourability = Parkourability.get(player); - if (parkourability == null) return; - Dodge dodge = parkourability.get(Dodge.class); - if (dodge.isDoing()) { - if (!parkourability.getServerLimitation().get(ParCoolConfig.Server.Booleans.DodgeProvideInvulnerableFrame)) - return; - if (event.getSource().isBypassArmor()) return; - if (dodge.getDoingTick() <= 10) { - event.setCanceled(true); - } - } + PlayerWrapper player = PlayerWrapper.getOrDefault(entity); + if (player == null) return; + Parkourability parkourability = Parkourability.get(player); + if (parkourability == null) return; + Dodge dodge = parkourability.get(Dodge.class); + if (!dodge.isDoing()) return; + if (!parkourability.getServerLimitation().get(ParCoolConfig.Server.Booleans.DodgeProvideInvulnerableFrame)) + return; + if (event.getSource().isBypassArmor()) return; + if (dodge.getDoingTick() <= 10) { + event.setCanceled(true); } } + @SubscribeEvent public static void onFall(LivingFallEvent event) { - if (event.getEntity() instanceof ServerPlayerEntity) { - ServerPlayerEntity player = (ServerPlayerEntity) event.getEntity(); + ServerPlayerWrapper serverPlayer = ServerPlayerWrapper.getFromEntityOrDefault(event); + if (serverPlayer != null) { - Parkourability parkourability = Parkourability.get(player); + Parkourability parkourability = Parkourability.get(serverPlayer); if (parkourability == null) return; if (parkourability.get(BreakfallReady.class).isDoing() @@ -45,7 +44,7 @@ public static void onFall(LivingFallEvent event) { boolean justTime = parkourability.get(BreakfallReady.class).getDoingTick() < 5; float distance = event.getDistance(); if (distance > 2) { - StartBreakfallMessage.send(player, justTime); + StartBreakfallMessage.send(serverPlayer, justTime); } if (distance < 6 || (justTime && distance < 8)) { event.setCanceled(true); @@ -53,11 +52,9 @@ public static void onFall(LivingFallEvent event) { event.setDamageMultiplier(event.getDamageMultiplier() * (justTime ? 0.4f : 0.6f)); } } - } else if (event.getEntity() instanceof PlayerEntity) { - PlayerEntity player = (PlayerEntity) event.getEntity(); - if (!player.isLocalPlayer()) { - return; - } + } else { + PlayerWrapper player = PlayerWrapper.getFromEntityOrDefault(event); + if (player == null || !player.isLocalPlayer()) return; Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; if (parkourability.getAdditionalProperties().getNotLandingTick() > 5 && event.getDistance() < 0.4f) { diff --git a/src/main/java/com/alrex/parcool/common/handlers/PlayerJoinHandler.java b/src/main/java/com/alrex/parcool/common/handlers/PlayerJoinHandler.java index 410f9119..df4e68ab 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/PlayerJoinHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/PlayerJoinHandler.java @@ -1,11 +1,11 @@ package com.alrex.parcool.common.handlers; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ClientSetting; import com.alrex.parcool.common.network.SyncClientInformationMessage; -import net.minecraft.client.entity.player.ClientPlayerEntity; import net.minecraft.entity.Entity; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.event.entity.EntityJoinWorldEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; @@ -14,14 +14,11 @@ public class PlayerJoinHandler { public static void onPlayerJoin(EntityJoinWorldEvent event) { if (!event.getWorld().isClientSide()) return; Entity entity = event.getEntity(); - if (entity instanceof PlayerEntity) { - PlayerEntity player = (PlayerEntity) entity; - if (player instanceof ClientPlayerEntity) { - Parkourability parkourability = Parkourability.get(player); - if (parkourability == null) return; - parkourability.getActionInfo().setClientSetting(ClientSetting.readFromLocalConfig()); - SyncClientInformationMessage.sync((ClientPlayerEntity) player, true); - } - } + PlayerWrapper player = PlayerWrapper.getOrDefault(entity); + if (player == null || !ClientPlayerWrapper.is(player)) return; + Parkourability parkourability = Parkourability.get(player); + if (parkourability == null) return; + parkourability.getActionInfo().setClientSetting(ClientSetting.readFromLocalConfig()); + SyncClientInformationMessage.sync(ClientPlayerWrapper.get(player), true); } } diff --git a/src/main/java/com/alrex/parcool/common/handlers/PlayerJumpHandler.java b/src/main/java/com/alrex/parcool/common/handlers/PlayerJumpHandler.java index eaa7e0d5..3ea492a8 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/PlayerJumpHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/PlayerJumpHandler.java @@ -1,19 +1,19 @@ package com.alrex.parcool.common.handlers; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.impl.ChargeJump; import com.alrex.parcool.common.action.impl.Dive; import com.alrex.parcool.common.action.impl.Flipping; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.event.entity.living.LivingEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; public class PlayerJumpHandler { @SubscribeEvent public static void onJump(LivingEvent.LivingJumpEvent event) { - if (!(event.getEntity() instanceof PlayerEntity)) return; - PlayerEntity player = (PlayerEntity) event.getEntity(); + PlayerWrapper player = PlayerWrapper.getFromEntityOrDefault(event); + if (player == null) return; Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; parkourability.getAdditionalProperties().onJump(); diff --git a/src/main/java/com/alrex/parcool/common/handlers/PlayerVisibilityHandler.java b/src/main/java/com/alrex/parcool/common/handlers/PlayerVisibilityHandler.java index b426c970..da557711 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/PlayerVisibilityHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/PlayerVisibilityHandler.java @@ -1,9 +1,9 @@ package com.alrex.parcool.common.handlers; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.impl.HideInBlock; import com.alrex.parcool.common.capability.Parkourability; import net.minecraft.entity.Entity; -import net.minecraft.entity.player.PlayerEntity; import net.minecraftforge.event.entity.living.LivingEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; @@ -11,13 +11,12 @@ public class PlayerVisibilityHandler { @SubscribeEvent public static void onLivingVisibilityEvent(LivingEvent.LivingVisibilityEvent event) { Entity entity = event.getEntity(); - if (entity instanceof PlayerEntity) { - PlayerEntity player = (PlayerEntity) entity; - Parkourability parkourability = Parkourability.get(player); - if (parkourability == null) return; - if (parkourability.get(HideInBlock.class).isDoing()) { - event.modifyVisibility(event.getVisibilityModifier() * 0.1); - } + PlayerWrapper player = PlayerWrapper.getOrDefault(entity); + if (player == null) return; + Parkourability parkourability = Parkourability.get(player); + if (parkourability == null) return; + if (parkourability.get(HideInBlock.class).isDoing()) { + event.modifyVisibility(event.getVisibilityModifier() * 0.1); } } diff --git a/src/main/java/com/alrex/parcool/common/info/ServerLimitation.java b/src/main/java/com/alrex/parcool/common/info/ServerLimitation.java index 5fa31b2d..b56f1261 100644 --- a/src/main/java/com/alrex/parcool/common/info/ServerLimitation.java +++ b/src/main/java/com/alrex/parcool/common/info/ServerLimitation.java @@ -1,11 +1,11 @@ package com.alrex.parcool.common.info; +import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.ActionList; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.server.limitation.Limitation; import com.alrex.parcool.server.limitation.Limitations; -import net.minecraft.entity.player.ServerPlayerEntity; import java.nio.ByteBuffer; import java.util.Arrays; @@ -144,7 +144,7 @@ void apply(Limitation limitation) { public abstract boolean isSynced(); - public static ServerLimitation get(ServerPlayerEntity player) { + public static ServerLimitation get(ServerPlayerWrapper player) { Collection limitations = Limitations.getLimitationsOf(player.getUUID()); Remote instance = new Remote(); diff --git a/src/main/java/com/alrex/parcool/common/item/zipline/ZiplineRopeItem.java b/src/main/java/com/alrex/parcool/common/item/zipline/ZiplineRopeItem.java index e1bb9508..fd081c6f 100644 --- a/src/main/java/com/alrex/parcool/common/item/zipline/ZiplineRopeItem.java +++ b/src/main/java/com/alrex/parcool/common/item/zipline/ZiplineRopeItem.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.item.zipline; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.block.zipline.ZiplineHookBlock; import com.alrex.parcool.common.block.zipline.ZiplineHookTileEntity; import com.alrex.parcool.common.block.zipline.ZiplineInfo; @@ -8,7 +9,6 @@ import com.alrex.parcool.common.zipline.ZiplineType; import net.minecraft.client.renderer.color.IItemColor; import net.minecraft.client.util.ITooltipFlag; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.item.ItemUseContext; @@ -92,7 +92,7 @@ public ActionResultType useOn(@Nonnull ItemUseContext context) { if (start.equals(end)) return ActionResultType.PASS; if (start.distSqr(end) > Zipline.MAXIMUM_DISTANCE * Zipline.MAXIMUM_DISTANCE) { if (context.getLevel().isClientSide()) { - PlayerEntity player = context.getPlayer(); + PlayerWrapper player = PlayerWrapper.get(context); if (player != null) { player.displayClientMessage(new TranslationTextComponent("parcool.message.zipline.too_far"), true); } @@ -100,7 +100,7 @@ public ActionResultType useOn(@Nonnull ItemUseContext context) { return ActionResultType.FAIL; } else if (Math.abs(end.getY() - start.getY()) * MathHelper.fastInvSqrt(Math.pow(end.getX() - start.getX(), 2) + Math.pow(end.getZ() - start.getZ(), 2)) > 1.) { if (context.getLevel().isClientSide()) { - PlayerEntity player = context.getPlayer(); + PlayerWrapper player = PlayerWrapper.get(context); if (player != null) { player.displayClientMessage(new TranslationTextComponent("parcool.message.zipline.too_steep"), true); } @@ -114,7 +114,7 @@ public ActionResultType useOn(@Nonnull ItemUseContext context) { ZiplineHookTileEntity startZipEntity = (ZiplineHookTileEntity) startEntity; ZiplineHookTileEntity endZipEntity = (ZiplineHookTileEntity) endEntity; if (getZiplineType(stack).getZipline(startZipEntity.getActualZiplinePoint(null), endZipEntity.getActualZiplinePoint(null)).conflictsWithSomething(context.getLevel())) { - PlayerEntity player = context.getPlayer(); + PlayerWrapper player = PlayerWrapper.get(context); if (player != null) { player.displayClientMessage(new TranslationTextComponent("parcool.message.zipline.obstacle_detected"), true); } @@ -122,7 +122,7 @@ public ActionResultType useOn(@Nonnull ItemUseContext context) { } if (!context.getLevel().isClientSide()) { if (!startZipEntity.connectTo(endZipEntity, new ZiplineInfo(getZiplineType(stack), getColor(stack)))) { - PlayerEntity player = context.getPlayer(); + PlayerWrapper player = PlayerWrapper.get(context); if (player != null) { player.displayClientMessage(new TranslationTextComponent("parcool.message.zipline.already_exist"), true); } @@ -130,7 +130,7 @@ public ActionResultType useOn(@Nonnull ItemUseContext context) { } stack.shrink(1); } - PlayerEntity player = context.getPlayer(); + PlayerWrapper player = PlayerWrapper.get(context); if (player != null) { player.playSound(SoundEvents.ZIPLINE_SET.get(), 1, 1); } @@ -139,7 +139,7 @@ public ActionResultType useOn(@Nonnull ItemUseContext context) { } else { removeBlockPosition(stack); if (context.getLevel().isClientSide()) { - PlayerEntity player = context.getPlayer(); + PlayerWrapper player = PlayerWrapper.get(context); if (player != null) { player.displayClientMessage(new TranslationTextComponent("parcool.message.zipline.point_not_found"), true); } @@ -150,7 +150,7 @@ public ActionResultType useOn(@Nonnull ItemUseContext context) { // Remove position info if (context.isSecondaryUseActive()) { if (context.getLevel().isClientSide()) { - PlayerEntity player = context.getPlayer(); + PlayerWrapper player = PlayerWrapper.get(context); if (player != null) { player.displayClientMessage(new TranslationTextComponent("parcool.message.zipline.reset_point"), true); } @@ -164,7 +164,7 @@ public ActionResultType useOn(@Nonnull ItemUseContext context) { if (context.getLevel().getBlockState(pos).getBlock() instanceof ZiplineHookBlock) { setBlockPosition(stack, pos); if (context.getLevel().isClientSide()) { - PlayerEntity player = context.getPlayer(); + PlayerWrapper player = PlayerWrapper.get(context); if (player != null) { player.displayClientMessage(new TranslationTextComponent("parcool.message.zipline.set_point", pos.toShortString()), true); } @@ -173,7 +173,7 @@ public ActionResultType useOn(@Nonnull ItemUseContext context) { } else if (context.isSecondaryUseActive()) { changeZiplineType(stack); if (context.getLevel().isClientSide()) { - PlayerEntity player = context.getPlayer(); + PlayerWrapper player = PlayerWrapper.get(context); if (player != null) { player.displayClientMessage(new TranslationTextComponent("parcool.message.zipline.change_tension", getZiplineType(stack).getTranslationName()), true); } diff --git a/src/main/java/com/alrex/parcool/common/network/StartBreakfallMessage.java b/src/main/java/com/alrex/parcool/common/network/StartBreakfallMessage.java index 97362da3..fcecc7c8 100644 --- a/src/main/java/com/alrex/parcool/common/network/StartBreakfallMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/StartBreakfallMessage.java @@ -1,18 +1,17 @@ package com.alrex.parcool.common.network; -import com.alrex.parcool.ParCool; +import com.alrex.parcool.api.compatibility.ChannelInstanceWrapper; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.action.impl.BreakfallReady; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; -import net.minecraft.client.Minecraft; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.network.PacketBuffer; import net.minecraft.network.PacketDirection; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.fml.network.NetworkEvent; -import net.minecraftforge.fml.network.PacketDistributor; import java.util.UUID; import java.util.function.Supplier; @@ -42,7 +41,7 @@ public static StartBreakfallMessage decode(PacketBuffer packet) { public void handleClient(Supplier contextSupplier) { contextSupplier.get().enqueueWork(() -> { if (contextSupplier.get().getNetworkManager().getDirection() == PacketDirection.CLIENTBOUND) { - PlayerEntity player = Minecraft.getInstance().player; + PlayerWrapper player = ClientPlayerWrapper.get(); if (player == null) return; if (!playerID.equals(player.getUUID())) return; @@ -61,10 +60,10 @@ public void handleClient(Supplier contextSupplier) { public void handleServer(Supplier contextSupplier) { } - public static void send(ServerPlayerEntity player, boolean justTimed) { + public static void send(ServerPlayerWrapper player, boolean justTimed) { StartBreakfallMessage message = new StartBreakfallMessage(); message.playerID = player.getUUID(); message.justTimed = justTimed; - ParCool.CHANNEL_INSTANCE.send(PacketDistributor.PLAYER.with(() -> player), message); + ChannelInstanceWrapper.send(player, message); } } diff --git a/src/main/java/com/alrex/parcool/common/network/SyncActionStateMessage.java b/src/main/java/com/alrex/parcool/common/network/SyncActionStateMessage.java index 8eedfde3..eb1cacbf 100644 --- a/src/main/java/com/alrex/parcool/common/network/SyncActionStateMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/SyncActionStateMessage.java @@ -1,16 +1,15 @@ package com.alrex.parcool.common.network; import com.alrex.parcool.ParCool; -import com.alrex.parcool.api.unstable.action.ParCoolActionEvent; +import com.alrex.parcool.api.compatibility.EventBusWrapper; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.capability.Parkourability; import net.minecraft.client.Minecraft; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.network.PacketBuffer; import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; -import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.fml.LogicalSide; import net.minecraftforge.fml.network.NetworkEvent; import net.minecraftforge.fml.network.PacketDistributor; @@ -46,9 +45,7 @@ public static SyncActionStateMessage decode(PacketBuffer packetBuffer) { @OnlyIn(Dist.DEDICATED_SERVER) public void handleServer(Supplier contextSupplier) { contextSupplier.get().enqueueWork(() -> { - PlayerEntity player; - - player = contextSupplier.get().getSender(); + PlayerWrapper player = PlayerWrapper.get(contextSupplier); ParCool.CHANNEL_INSTANCE.send(PacketDistributor.ALL.noArg(), this); if (player == null) return; @@ -67,13 +64,13 @@ public void handleServer(Supplier contextSupplier) { action.onStart(player, parkourability, startData); startData.rewind(); action.onStartInServer(player, parkourability, item.getBuffer()); - MinecraftForge.EVENT_BUS.post(new ParCoolActionEvent.StartEvent(player, action)); + EventBusWrapper.startEvent(player, action); break; case Finish: action.setDoing(false); action.onStopInServer(player); action.onStop(player); - MinecraftForge.EVENT_BUS.post(new ParCoolActionEvent.StopEvent(player, action)); + EventBusWrapper.stopEvent(player, action); break; case Normal: action.restoreSynchronizedState(item.getBuffer()); @@ -87,16 +84,16 @@ public void handleServer(Supplier contextSupplier) { @OnlyIn(Dist.CLIENT) public void handleClient(Supplier contextSupplier) { contextSupplier.get().enqueueWork(() -> { - PlayerEntity player; + PlayerWrapper player; boolean clientSide; if (contextSupplier.get().getDirection().getReceptionSide() == LogicalSide.CLIENT) { World world = Minecraft.getInstance().level; if (world == null) return; - player = world.getPlayerByUUID(senderUUID); + player = PlayerWrapper.get(world, senderUUID); if (player == null || player.isLocalPlayer()) return; clientSide = true; } else { - player = contextSupplier.get().getSender(); + player = PlayerWrapper.get(contextSupplier); ParCool.CHANNEL_INSTANCE.send(PacketDistributor.ALL.noArg(), this); if (player == null) return; clientSide = false; @@ -121,7 +118,7 @@ public void handleClient(Supplier contextSupplier) { } else { action.onStartInServer(player, parkourability, startData); } - MinecraftForge.EVENT_BUS.post(new ParCoolActionEvent.StartEvent(player, action)); + EventBusWrapper.startEvent(player, action); break; case Finish: action.setDoing(false); @@ -131,7 +128,7 @@ public void handleClient(Supplier contextSupplier) { action.onStopInServer(player); } action.onStop(player); - MinecraftForge.EVENT_BUS.post(new ParCoolActionEvent.StopEvent(player, action)); + EventBusWrapper.stopEvent(player, action); break; case Normal: action.restoreSynchronizedState(item.getBuffer()); @@ -143,7 +140,7 @@ public void handleClient(Supplier contextSupplier) { } @OnlyIn(Dist.CLIENT) - public static void sync(PlayerEntity player, Encoder builder) { + public static void sync(PlayerWrapper player, Encoder builder) { ByteBuffer buffer1 = builder.build(); if (buffer1.limit() == 0) return; SyncActionStateMessage message = new SyncActionStateMessage(); diff --git a/src/main/java/com/alrex/parcool/common/network/SyncClientInformationMessage.java b/src/main/java/com/alrex/parcool/common/network/SyncClientInformationMessage.java index 065405ea..ed45016e 100644 --- a/src/main/java/com/alrex/parcool/common/network/SyncClientInformationMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/SyncClientInformationMessage.java @@ -1,15 +1,14 @@ package com.alrex.parcool.common.network; import com.alrex.parcool.ParCool; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.MinecraftServerWrapper; +import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ClientSetting; import com.alrex.parcool.server.limitation.Limitations; -import net.minecraft.client.Minecraft; -import net.minecraft.client.entity.player.ClientPlayerEntity; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.network.PacketBuffer; -import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.fml.LogicalSide; @@ -48,14 +47,12 @@ public static SyncClientInformationMessage decode(PacketBuffer packet) { @OnlyIn(Dist.CLIENT) public void handleClient(Supplier contextSupplier) { contextSupplier.get().enqueueWork(() -> { - PlayerEntity player; + PlayerWrapper player; if (contextSupplier.get().getDirection().getReceptionSide() == LogicalSide.CLIENT) { - World world = Minecraft.getInstance().level; - if (world == null) return; - player = world.getPlayerByUUID(playerID); + player = MinecraftServerWrapper.getPlayer(playerID); if (player == null) return; } else { - ServerPlayerEntity serverPlayer = contextSupplier.get().getSender(); + ServerPlayerWrapper serverPlayer = ServerPlayerWrapper.get(contextSupplier); player = serverPlayer; if (player == null) return; ParCool.CHANNEL_INSTANCE.send(PacketDistributor.ALL.noArg(), this); @@ -76,7 +73,7 @@ public void handleClient(Supplier contextSupplier) { public void handleServer(Supplier contextSupplier) { contextSupplier.get().enqueueWork(() -> { - ServerPlayerEntity player = contextSupplier.get().getSender(); + ServerPlayerWrapper player = ServerPlayerWrapper.get(contextSupplier); if (player == null) return; ParCool.CHANNEL_INSTANCE.send(PacketDistributor.ALL.noArg(), this); @@ -92,12 +89,12 @@ public void handleServer(Supplier contextSupplier) { contextSupplier.get().setPacketHandled(true); } - public void logReceived(PlayerEntity player) { - ParCool.LOGGER.log(Level.INFO, "Received Client Information of [" + player.getGameProfile().getName() + "]"); + public void logReceived(PlayerWrapper player) { + ParCool.LOGGER.log(Level.INFO, "Received Client Information of [" + player.getName() + "]"); } @OnlyIn(Dist.CLIENT) - public static void sync(ClientPlayerEntity player, boolean requestSendLimitation) { + public static void sync(ClientPlayerWrapper player, boolean requestSendLimitation) { Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; SyncClientInformationMessage message = new SyncClientInformationMessage(); diff --git a/src/main/java/com/alrex/parcool/common/network/SyncServerInfoMessage.java b/src/main/java/com/alrex/parcool/common/network/SyncServerInfoMessage.java index 6e88f474..9997894f 100644 --- a/src/main/java/com/alrex/parcool/common/network/SyncServerInfoMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/SyncServerInfoMessage.java @@ -1,22 +1,18 @@ package com.alrex.parcool.common.network; import com.alrex.parcool.ParCool; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.PlayerPacketDistributor; +import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ServerLimitation; -import net.minecraft.client.Minecraft; -import net.minecraft.client.entity.player.ClientPlayerEntity; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.network.PacketBuffer; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.fml.network.NetworkEvent; -import net.minecraftforge.fml.network.PacketDistributor; import org.apache.logging.log4j.Level; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - import java.nio.ByteBuffer; import java.util.function.Supplier; @@ -50,7 +46,7 @@ public static SyncServerInfoMessage decode(PacketBuffer packet) { @OnlyIn(Dist.CLIENT) public void handle(Supplier contextSupplier) { contextSupplier.get().enqueueWork(() -> { - ClientPlayerEntity player = Minecraft.getInstance().player; + ClientPlayerWrapper player = ClientPlayerWrapper.get(); if (player == null) return; Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; @@ -66,21 +62,21 @@ public void handle(Supplier contextSupplier) { contextSupplier.get().setPacketHandled(true); } - public void logReceived(PlayerEntity player) { - ParCool.LOGGER.log(Level.INFO, "Received Server Limitation of [" + player.getGameProfile().getName() + "]"); + public void logReceived(PlayerWrapper player) { + ParCool.LOGGER.log(Level.INFO, "Received Server Limitation of [" + player.getName() + "]"); } - public static void sync(ServerPlayerEntity player) { + public static void sync(ServerPlayerWrapper player) { Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; SyncServerInfoMessage msg = new SyncServerInfoMessage(); parkourability.getActionInfo().getServerLimitation().writeTo(msg.limitationData); msg.limitationData.flip(); msg.staminaNeedSync = false; - ParCool.CHANNEL_INSTANCE.send(PacketDistributor.PLAYER.with(() -> player), msg); + ParCool.CHANNEL_INSTANCE.send(PlayerPacketDistributor.with(player), msg); } - public static void syncWithStamina(ServerPlayerEntity player, IStamina stamina) { + public static void syncWithStamina(ServerPlayerWrapper player, IStamina stamina) { Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; SyncServerInfoMessage msg = new SyncServerInfoMessage(); @@ -91,6 +87,6 @@ public static void syncWithStamina(ServerPlayerEntity player, IStamina stamina) msg.staminaExhausted = stamina.isExhausted(); msg.staminaValue = stamina.get(); } - ParCool.CHANNEL_INSTANCE.send(PacketDistributor.PLAYER.with(() -> player), msg); + ParCool.CHANNEL_INSTANCE.send(PlayerPacketDistributor.with(player), msg); } } diff --git a/src/main/java/com/alrex/parcool/common/network/SyncStaminaMessage.java b/src/main/java/com/alrex/parcool/common/network/SyncStaminaMessage.java index 02c93328..4692aa8b 100644 --- a/src/main/java/com/alrex/parcool/common/network/SyncStaminaMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/SyncStaminaMessage.java @@ -1,11 +1,11 @@ package com.alrex.parcool.common.network; import com.alrex.parcool.ParCool; +import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.stamina.OtherStamina; import net.minecraft.client.Minecraft; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraft.network.PacketBuffer; import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; @@ -50,8 +50,8 @@ public static SyncStaminaMessage decode(PacketBuffer packet) { @OnlyIn(Dist.DEDICATED_SERVER) public void handleServer(Supplier contextSupplier) { contextSupplier.get().enqueueWork(() -> { - ServerPlayerEntity player; - player = contextSupplier.get().getSender(); + ServerPlayerWrapper player; + player = ServerPlayerWrapper.get(contextSupplier); ParCool.CHANNEL_INSTANCE.send(PacketDistributor.ALL.noArg(), this); if (player == null) return; IStamina stamina = IStamina.get(player); @@ -71,15 +71,15 @@ public void handleServer(Supplier contextSupplier) { @OnlyIn(Dist.CLIENT) public void handleClient(Supplier contextSupplier) { contextSupplier.get().enqueueWork(() -> { - ServerPlayerEntity serverPlayer = null; - PlayerEntity player; + ServerPlayerWrapper serverPlayer = null; + PlayerWrapper player; if (contextSupplier.get().getDirection().getReceptionSide() == LogicalSide.CLIENT) { World world = Minecraft.getInstance().level; if (world == null) return; - player = world.getPlayerByUUID(playerID); + player = PlayerWrapper.get(world, playerID); if (player == null || player.isLocalPlayer()) return; } else { - player = serverPlayer = contextSupplier.get().getSender(); + player = serverPlayer = ServerPlayerWrapper.get(contextSupplier); ParCool.CHANNEL_INSTANCE.send(PacketDistributor.ALL.noArg(), this); if (player == null) return; } @@ -98,7 +98,7 @@ public void handleClient(Supplier contextSupplier) { } @OnlyIn(Dist.CLIENT) - public static void sync(PlayerEntity player) { + public static void sync(PlayerWrapper player) { IStamina stamina = IStamina.get(player); if (stamina == null || !player.isLocalPlayer()) return; diff --git a/src/main/java/com/alrex/parcool/common/zipline/Zipline.java b/src/main/java/com/alrex/parcool/common/zipline/Zipline.java index f2c1b786..8fe0700e 100644 --- a/src/main/java/com/alrex/parcool/common/zipline/Zipline.java +++ b/src/main/java/com/alrex/parcool/common/zipline/Zipline.java @@ -1,7 +1,7 @@ package com.alrex.parcool.common.zipline; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.entity.zipline.ZiplineRopeEntity; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.vector.Vector3d; @@ -47,12 +47,12 @@ public double getHorizontalDistance() { } @Nullable - public static ZiplineRopeEntity getHangableZipline(World world, PlayerEntity player) { + public static ZiplineRopeEntity getHangableZipline(World world, PlayerWrapper player) { return getHangableZipline(world, player, null); } @Nullable - public static ZiplineRopeEntity getHangableZipline(World world, PlayerEntity player, @Nullable ZiplineRopeEntity except) { + public static ZiplineRopeEntity getHangableZipline(World world, PlayerWrapper player, @Nullable ZiplineRopeEntity except) { List entities = world.getEntitiesOfClass( ZiplineRopeEntity.class, player.getBoundingBox().inflate(MAXIMUM_DISTANCE * 0.52) diff --git a/src/main/java/com/alrex/parcool/extern/betterthirdperson/BetterThirdPersonManager.java b/src/main/java/com/alrex/parcool/extern/betterthirdperson/BetterThirdPersonManager.java index 507a3f99..543bea14 100644 --- a/src/main/java/com/alrex/parcool/extern/betterthirdperson/BetterThirdPersonManager.java +++ b/src/main/java/com/alrex/parcool/extern/betterthirdperson/BetterThirdPersonManager.java @@ -1,12 +1,12 @@ package com.alrex.parcool.extern.betterthirdperson; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.action.impl.Dodge; import com.alrex.parcool.extern.ModManager; import com.alrex.parcool.utilities.MathUtil; import io.socol.betterthirdperson.BetterThirdPerson; import io.socol.betterthirdperson.api.CustomCamera; import net.minecraft.client.Minecraft; -import net.minecraft.client.entity.player.ClientPlayerEntity; public class BetterThirdPersonManager extends ModManager { public BetterThirdPersonManager() { @@ -15,23 +15,16 @@ public BetterThirdPersonManager() { public Dodge.DodgeDirection handleCustomCameraRotationForDodge(Dodge.DodgeDirection direction) { if (!isInstalled()) return direction; - if (!Minecraft.getInstance().options.getCameraType().isFirstPerson()) { - ClientPlayerEntity player = Minecraft.getInstance().player; - if (player == null) return direction; - if (!BetterThirdPerson.getCameraManager().hasCustomCamera()) return direction; - CustomCamera camera = BetterThirdPerson.getCameraManager().getCustomCamera(); - float yaw = MathUtil.normalizeDegree(camera.getPlayerRotation().getYaw() - camera.getCameraRotation().getYaw()); - float yawAbs = Math.abs(yaw); - if (yawAbs < 45) { - return direction; - } else if (yawAbs > 135) { - return direction.inverse(); - } else if (yaw < 0) { - return direction.right(); - } else { - return direction.left(); - } - } - return direction; + if (Minecraft.getInstance().options.getCameraType().isFirstPerson()) return direction; + ClientPlayerWrapper player = ClientPlayerWrapper.get(); + if (player == null) return direction; + if (!BetterThirdPerson.getCameraManager().hasCustomCamera()) return direction; + CustomCamera camera = BetterThirdPerson.getCameraManager().getCustomCamera(); + float yaw = MathUtil.normalizeDegree(camera.getPlayerRotation().getYaw() - camera.getCameraRotation().getYaw()); + float yawAbs = Math.abs(yaw); + if (yawAbs < 45) return direction; + if (yawAbs > 135) direction.inverse(); + if (yaw < 0) direction.right(); + return direction.left(); } } diff --git a/src/main/java/com/alrex/parcool/extern/shouldersurfing/ShoulderSurfingManager.java b/src/main/java/com/alrex/parcool/extern/shouldersurfing/ShoulderSurfingManager.java index 3c2035dc..8c036444 100644 --- a/src/main/java/com/alrex/parcool/extern/shouldersurfing/ShoulderSurfingManager.java +++ b/src/main/java/com/alrex/parcool/extern/shouldersurfing/ShoulderSurfingManager.java @@ -1,12 +1,12 @@ package com.alrex.parcool.extern.shouldersurfing; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.action.impl.Dodge; import com.alrex.parcool.extern.ModManager; import com.alrex.parcool.utilities.MathUtil; import com.github.exopandora.shouldersurfing.api.client.IShoulderSurfingCamera; import com.github.exopandora.shouldersurfing.api.client.ShoulderSurfing; import net.minecraft.client.Minecraft; -import net.minecraft.client.entity.player.ClientPlayerEntity; public class ShoulderSurfingManager extends ModManager { public ShoulderSurfingManager() { @@ -15,23 +15,16 @@ public ShoulderSurfingManager() { public Dodge.DodgeDirection handleCustomCameraRotationForDodge(Dodge.DodgeDirection direction) { if (!isInstalled()) return direction; - if (!Minecraft.getInstance().options.getCameraType().isFirstPerson()) { - if (!ShoulderSurfing.getInstance().isShoulderSurfing()) return direction; - ClientPlayerEntity player = Minecraft.getInstance().player; - if (player == null) return direction; - IShoulderSurfingCamera camera = ShoulderSurfing.getInstance().getCamera(); - float yaw = MathUtil.normalizeDegree(camera.getYRot() - player.yRot); - float yawAbs = Math.abs(yaw); - if (yawAbs < 45) { - return direction; - } else if (yawAbs > 135) { - return direction.inverse(); - } else if (yaw < 0) { - return direction.left(); - } else { - return direction.right(); - } - } - return direction; + if (Minecraft.getInstance().options.getCameraType().isFirstPerson()) return direction; + if (!ShoulderSurfing.getInstance().isShoulderSurfing()) return direction; + ClientPlayerWrapper player = ClientPlayerWrapper.get(); + if (player == null) return direction; + IShoulderSurfingCamera camera = ShoulderSurfing.getInstance().getCamera(); + float yaw = MathUtil.normalizeDegree(camera.getYRot() - player.getYRot()); + float yawAbs = Math.abs(yaw); + if (yawAbs < 45) return direction; + if (yawAbs > 135) return direction.inverse(); + if (yaw < 0) return direction.left(); + return direction.right(); } } diff --git a/src/main/java/com/alrex/parcool/mixin/client/ClientPlayerEntityMixin.java b/src/main/java/com/alrex/parcool/mixin/client/ClientPlayerEntityMixin.java index b69b1450..044a87bc 100644 --- a/src/main/java/com/alrex/parcool/mixin/client/ClientPlayerEntityMixin.java +++ b/src/main/java/com/alrex/parcool/mixin/client/ClientPlayerEntityMixin.java @@ -1,12 +1,12 @@ package com.alrex.parcool.mixin.client; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; import com.mojang.authlib.GameProfile; import net.minecraft.client.entity.player.AbstractClientPlayerEntity; import net.minecraft.client.entity.player.ClientPlayerEntity; import net.minecraft.client.world.ClientWorld; import net.minecraft.entity.MoverType; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.math.vector.Vector3d; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.Shadow; @@ -28,7 +28,7 @@ public ClientPlayerEntityMixin(ClientWorld p_i50991_1_, GameProfile p_i50991_2_) @Inject(method = "isShiftKeyDown", at = @At("HEAD"), cancellable = true) public void onIsShiftKeyDown(CallbackInfoReturnable cir) { - Parkourability parkourability = Parkourability.get((PlayerEntity) (Object) this); + Parkourability parkourability = Parkourability.get(ClientPlayerWrapper.get(this)); if (parkourability == null) return; if (parkourability.getBehaviorEnforcer().cancelSneak()) { @@ -37,9 +37,9 @@ public void onIsShiftKeyDown(CallbackInfoReturnable cir) { } @Inject(method = "aiStep", at = @At("HEAD")) public void onAiStep(CallbackInfo ci) { - ClientPlayerEntity player = (ClientPlayerEntity) (Object) this; + ClientPlayerWrapper player = ClientPlayerWrapper.get(this); if (player.isLocalPlayer()) { - boolean flag = !player.input.hasForwardImpulse() || !((float) player.getFoodData().getFoodLevel() > 6.0F || this.abilities.mayfly); + boolean flag = !player.hasForwardImpulse() || !((float) player.getFoodLevel() > 6.0F || this.abilities.mayfly); boolean flag1 = flag || this.isInWater() && !this.isUnderWater(); if (oldSprinting && !flag1) { player.setSprinting(true); @@ -50,7 +50,7 @@ public void onAiStep(CallbackInfo ci) { @Inject(method = "move", at = @At("HEAD"), cancellable = true) public void onMove(MoverType moverType, Vector3d movement, CallbackInfo ci) { - ClientPlayerEntity player = (ClientPlayerEntity) (Object) this; + ClientPlayerWrapper player = ClientPlayerWrapper.get(this); Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; Vector3d enforcedPos = parkourability.getBehaviorEnforcer().getEnforcedPosition(); @@ -73,7 +73,7 @@ public void onMove(MoverType moverType, Vector3d movement, CallbackInfo ci) { @Inject(method = "setSprinting", at = @At("HEAD"), cancellable = true) public void onSetSprinting(boolean sprint, CallbackInfo ci) { - Parkourability parkourability = Parkourability.get((ClientPlayerEntity) (Object) this); + Parkourability parkourability = Parkourability.get(ClientPlayerWrapper.get(this)); if (parkourability != null && parkourability.getBehaviorEnforcer().cancelSprint()) { ci.cancel(); } diff --git a/src/main/java/com/alrex/parcool/mixin/client/ClientWorldMixin.java b/src/main/java/com/alrex/parcool/mixin/client/ClientWorldMixin.java index 2058ca05..0058c01d 100644 --- a/src/main/java/com/alrex/parcool/mixin/client/ClientWorldMixin.java +++ b/src/main/java/com/alrex/parcool/mixin/client/ClientWorldMixin.java @@ -1,10 +1,9 @@ package com.alrex.parcool.mixin.client; +import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.action.impl.HideInBlock; import com.alrex.parcool.common.capability.Parkourability; import net.minecraft.block.BlockState; -import net.minecraft.client.Minecraft; -import net.minecraft.client.entity.player.ClientPlayerEntity; import net.minecraft.client.world.ClientWorld; import net.minecraft.profiler.IProfiler; import net.minecraft.util.RegistryKey; @@ -27,7 +26,7 @@ protected ClientWorldMixin(ISpawnWorldInfo p_i241925_1_, RegistryKey p_i2 @Inject(method = "setBlocksDirty", at = @At("TAIL")) public void onSetBlocksDirty(BlockPos pos, BlockState oldState, BlockState newState, CallbackInfo ci) { - ClientPlayerEntity player = Minecraft.getInstance().player; + ClientPlayerWrapper player = ClientPlayerWrapper.get(); if (player == null) return; Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; diff --git a/src/main/java/com/alrex/parcool/mixin/client/PlayerModelMixin.java b/src/main/java/com/alrex/parcool/mixin/client/PlayerModelMixin.java index f7016366..6cff2bad 100644 --- a/src/main/java/com/alrex/parcool/mixin/client/PlayerModelMixin.java +++ b/src/main/java/com/alrex/parcool/mixin/client/PlayerModelMixin.java @@ -1,5 +1,6 @@ package com.alrex.parcool.mixin.client; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.config.ParCoolConfig; @@ -8,7 +9,6 @@ import net.minecraft.client.renderer.entity.model.PlayerModel; import net.minecraft.client.renderer.model.ModelRenderer; import net.minecraft.entity.LivingEntity; -import net.minecraft.entity.player.PlayerEntity; import org.spongepowered.asm.mixin.Final; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.Shadow; @@ -50,9 +50,9 @@ public PlayerModelMixin(float p_i1148_1_) { @Inject(method = "Lnet/minecraft/client/renderer/entity/model/PlayerModel;setupAnim(Lnet/minecraft/entity/LivingEntity;FFFFF)V", at = @At("HEAD"), cancellable = true) protected void onSetupAnimHead(T entity, float limbSwing, float limbSwingAmount, float ageInTicks, float netHeadYaw, float headPitch, CallbackInfo info) { - if (!(entity instanceof PlayerEntity)) return; + PlayerWrapper player = PlayerWrapper.getOrDefault(entity); + if (player == null) return; PlayerModel model = (PlayerModel) (Object) this; - PlayerEntity player = (PlayerEntity) entity; if (player.isLocalPlayer() && Minecraft.getInstance().options.getCameraType().isFirstPerson() && !ParCoolConfig.Client.Booleans.EnableFPVAnimation.get() @@ -83,8 +83,8 @@ protected void onSetupAnimHead(T entity, float limbSwing, float limbSwingAmount, @Inject(method = "Lnet/minecraft/client/renderer/entity/model/PlayerModel;setupAnim(Lnet/minecraft/entity/LivingEntity;FFFFF)V", at = @At("TAIL")) protected void onSetupAnimTail(T entity, float limbSwing, float limbSwingAmount, float ageInTicks, float netHeadYaw, float headPitch, CallbackInfo info) { - if (!(entity instanceof PlayerEntity)) return; - PlayerEntity player = (PlayerEntity) entity; + PlayerWrapper player = PlayerWrapper.getOrDefault(entity); + if (player == null) return; if (player.isLocalPlayer() && Minecraft.getInstance().options.getCameraType().isFirstPerson() && !ParCoolConfig.Client.Booleans.EnableFPVAnimation.get() diff --git a/src/main/java/com/alrex/parcool/mixin/client/PlayerRendererMixin.java b/src/main/java/com/alrex/parcool/mixin/client/PlayerRendererMixin.java index 41d7b5ee..41695408 100644 --- a/src/main/java/com/alrex/parcool/mixin/client/PlayerRendererMixin.java +++ b/src/main/java/com/alrex/parcool/mixin/client/PlayerRendererMixin.java @@ -1,5 +1,6 @@ package com.alrex.parcool.mixin.client; +import com.alrex.parcool.api.compatibility.AbstractClientPlayerWrapper; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.common.capability.Animation; import com.mojang.blaze3d.matrix.MatrixStack; @@ -26,25 +27,27 @@ public PlayerRendererMixin(EntityRendererManager p_i50965_1_, PlayerModel cir) { return; } - PlayerEntity player = (PlayerEntity) (Object) this; + PlayerWrapper player = PlayerWrapper.get(this); Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; HideInBlock ability = parkourability.get(HideInBlock.class); Tuple area = ability.getHidingArea(); if (ability.isDoing() && area != null) { int areaHeight = area.getB().getY() - area.getA().getY() + 1; - float eyeHeight = player.getEyeHeight(Pose.STANDING); + float eyeHeight = player.getEyeHeight(); if (areaHeight < eyeHeight) { cir.setReturnValue(eyeHeight); } else { @@ -47,7 +47,7 @@ public void onIsInWall(CallbackInfoReturnable cir) { if (!(((Object) this) instanceof PlayerEntity)) { return; } - PlayerEntity player = (PlayerEntity) (Object) this; + PlayerWrapper player = PlayerWrapper.get(this); Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; HideInBlock hideInBlock = parkourability.get(HideInBlock.class); diff --git a/src/main/java/com/alrex/parcool/mixin/common/LivingEntityMixin.java b/src/main/java/com/alrex/parcool/mixin/common/LivingEntityMixin.java index 86bf5b9e..f2d6a0bf 100644 --- a/src/main/java/com/alrex/parcool/mixin/common/LivingEntityMixin.java +++ b/src/main/java/com/alrex/parcool/mixin/common/LivingEntityMixin.java @@ -1,6 +1,8 @@ package com.alrex.parcool.mixin.common; -import com.alrex.parcool.api.unstable.action.ParCoolActionEvent; +import com.alrex.parcool.api.compatibility.EventBusWrapper; +import com.alrex.parcool.api.compatibility.LivingEntityWrapper; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.impl.ChargeJump; import com.alrex.parcool.common.action.impl.ClimbPoles; import com.alrex.parcool.common.action.impl.ClimbUp; @@ -9,7 +11,6 @@ import net.minecraft.entity.Entity; import net.minecraft.entity.EntityType; import net.minecraft.entity.LivingEntity; -import net.minecraft.entity.player.PlayerEntity; import net.minecraft.nbt.CompoundNBT; import net.minecraft.util.Direction; import net.minecraft.util.math.AxisAlignedBB; @@ -17,7 +18,6 @@ import net.minecraft.util.math.MathHelper; import net.minecraft.world.World; import net.minecraftforge.common.ForgeConfig; -import net.minecraftforge.common.MinecraftForge; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.Shadow; import org.spongepowered.asm.mixin.Unique; @@ -47,17 +47,15 @@ public void onClimbable(CallbackInfoReturnable cir) { if (this.isSpectator()) { cir.setReturnValue(false); } else { - LivingEntity entity = (LivingEntity) (Object) this; - if (!(entity instanceof PlayerEntity)) { - return; - } - PlayerEntity player = (PlayerEntity) entity; + LivingEntityWrapper entity = LivingEntityWrapper.get(this); + PlayerWrapper player = PlayerWrapper.getOrDefault(entity); + if (player == null) return; Parkourability parkourability = Parkourability.get(player); if (parkourability == null) { return; } if (!parkourability.getActionInfo().can(ClimbPoles.class) - || MinecraftForge.EVENT_BUS.post(new ParCoolActionEvent.TryToStartEvent(player, parkourability.get(ClimbPoles.class))) + || EventBusWrapper.tryToStartEvent(player, parkourability.get(ClimbPoles.class)) ) { return; } @@ -70,7 +68,7 @@ public void onClimbable(CallbackInfoReturnable cir) { } BlockPos blockpos = this.blockPosition(); BlockState blockstate = this.getFeetBlockState(); - boolean onLadder = parCool$isLivingOnCustomLadder(blockstate, entity.level, blockpos, entity); + boolean onLadder = parCool$isLivingOnCustomLadder(blockstate, entity.getLevel(), blockpos, entity); if (onLadder) { cir.setReturnValue(true); } @@ -78,8 +76,8 @@ public void onClimbable(CallbackInfoReturnable cir) { } @Unique - public boolean parCool$isLivingOnCustomLadder(@Nonnull BlockState state, @Nonnull World world, @Nonnull BlockPos pos, @Nonnull LivingEntity entity) { - boolean isSpectator = (entity instanceof PlayerEntity && entity.isSpectator()); + public boolean parCool$isLivingOnCustomLadder(@Nonnull BlockState state, @Nonnull World world, @Nonnull BlockPos pos, @Nonnull LivingEntityWrapper entity) { + boolean isSpectator = PlayerWrapper.is(entity) && entity.isSpectator(); if (isSpectator) return false; if (!ForgeConfig.SERVER.fullBoundingBoxLadders.get()) { return parCool$isCustomLadder(state, world, pos, entity); @@ -107,7 +105,7 @@ public void onClimbable(CallbackInfoReturnable cir) { } @Unique - private boolean parCool$isCustomLadder(BlockState state, World world, BlockPos pos, LivingEntity entity) { + private boolean parCool$isCustomLadder(BlockState state, World world, BlockPos pos, LivingEntityWrapper entity) { Block block = state.getBlockState().getBlock(); if (block instanceof FourWayBlock) { int zCount = 0; diff --git a/src/main/java/com/alrex/parcool/mixin/common/PlayerEntityMixin.java b/src/main/java/com/alrex/parcool/mixin/common/PlayerEntityMixin.java index 5b618c29..c471d827 100644 --- a/src/main/java/com/alrex/parcool/mixin/common/PlayerEntityMixin.java +++ b/src/main/java/com/alrex/parcool/mixin/common/PlayerEntityMixin.java @@ -1,5 +1,6 @@ package com.alrex.parcool.mixin.common; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; import net.minecraft.entity.EntityType; import net.minecraft.entity.LivingEntity; @@ -20,7 +21,7 @@ protected PlayerEntityMixin(EntityType p_i48577_1_, Worl @Inject(method = "tryToStartFallFlying", at = @At("HEAD"), cancellable = true) public void onTryToStartFallFlying(CallbackInfoReturnable cir) { - PlayerEntity player = (PlayerEntity) (Object) this; + PlayerWrapper player = PlayerWrapper.get(this); Parkourability parkourability = Parkourability.get(player); if (parkourability != null && parkourability.getBehaviorEnforcer().cancelFallFlying()) { cir.setReturnValue(false); @@ -29,7 +30,7 @@ public void onTryToStartFallFlying(CallbackInfoReturnable cir) { @Inject(method = "jumpFromGround", at = @At("HEAD"), cancellable = true) public void onJumpFromGround(CallbackInfo ci) { - Parkourability parkourability = Parkourability.get((PlayerEntity) (Object) this); + Parkourability parkourability = Parkourability.get(PlayerWrapper.get(this)); if (parkourability == null) return; if (parkourability.getBehaviorEnforcer().cancelJump()) { ci.cancel(); @@ -38,7 +39,7 @@ public void onJumpFromGround(CallbackInfo ci) { @Inject(method = "isStayingOnGroundSurface", at = @At("HEAD"), cancellable = true) public void onIsStayingOnGroundSurface(CallbackInfoReturnable cir) { - Parkourability parkourability = Parkourability.get((PlayerEntity) (Object) this); + Parkourability parkourability = Parkourability.get(PlayerWrapper.get(this)); if (parkourability == null) return; if (parkourability.getBehaviorEnforcer().cancelDescendFromEdge()) { cir.setReturnValue(true); @@ -47,7 +48,7 @@ public void onIsStayingOnGroundSurface(CallbackInfoReturnable cir) { @Inject(method = "shouldShowName", at = @At("HEAD"), cancellable = true) public void onShouldShowName(CallbackInfoReturnable cir) { - Parkourability parkourability = Parkourability.get((PlayerEntity) (Object) this); + Parkourability parkourability = Parkourability.get(PlayerWrapper.get(this)); if (parkourability == null) return; if (parkourability.getBehaviorEnforcer().cancelShowingName()) { cir.setReturnValue(false); diff --git a/src/main/java/com/alrex/parcool/server/command/impl/ControlLimitationCommand.java b/src/main/java/com/alrex/parcool/server/command/impl/ControlLimitationCommand.java index f13fa257..41e8c4bc 100644 --- a/src/main/java/com/alrex/parcool/server/command/impl/ControlLimitationCommand.java +++ b/src/main/java/com/alrex/parcool/server/command/impl/ControlLimitationCommand.java @@ -1,5 +1,7 @@ package com.alrex.parcool.server.command.impl; +import com.alrex.parcool.api.compatibility.MinecraftServerWrapper; +import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.api.unstable.Limitation; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.ActionList; @@ -19,11 +21,8 @@ import net.minecraft.command.CommandSource; import net.minecraft.command.Commands; import net.minecraft.command.arguments.EntityArgument; -import net.minecraft.entity.player.ServerPlayerEntity; -import net.minecraft.server.MinecraftServer; import net.minecraft.util.text.StringTextComponent; import net.minecraft.util.text.TranslationTextComponent; - import javax.annotation.Nullable; import java.util.Collection; import java.util.Collections; @@ -270,7 +269,16 @@ public class ControlLimitationCommand { ); } - private static List getLimitationInstance(Collection players, @Nullable Limitation.ID id, @Nullable MinecraftServer server) { + private static List getLimitationInstance(CommandContext context, boolean hasID, boolean hasPlayer) + throws CommandSyntaxException { + return getLimitationInstance( + hasPlayer ? Collections.singletonList(ServerPlayerWrapper.getPlayer(context, ARGS_NAME_ACTION)) : Collections.emptyList(), + hasID ? LimitationIDArgumentType.getLimitationID(context, ARGS_NAME_LIMITATION_ID) : null, + MinecraftServerWrapper.get(context) + ); + } + + private static List getLimitationInstance(Collection players, @Nullable Limitation.ID id, @Nullable MinecraftServerWrapper server) { if (players.isEmpty()) { if (server != null) {// global limitation return Collections.singletonList(Limitation.getGlobal(server)); @@ -280,13 +288,13 @@ private static List getLimitationInstance(Collection list = new LinkedList<>(); - for (ServerPlayerEntity player : players) { + for (ServerPlayerWrapper player : players) { list.add(Limitation.get(player, id)); } return list; } else {//individual limitation LinkedList list = new LinkedList<>(); - for (ServerPlayerEntity player : players) { + for (ServerPlayerWrapper player : players) { list.add(Limitation.getIndividual(player)); } return list; @@ -295,11 +303,7 @@ private static List getLimitationInstance(Collection context, boolean hasID, boolean hasPlayer) throws CommandSyntaxException { - List limitations = getLimitationInstance( - hasPlayer ? Collections.singletonList(EntityArgument.getPlayer(context, ARGS_NAME_PLAYER)) : Collections.emptyList(), - hasID ? LimitationIDArgumentType.getLimitationID(context, ARGS_NAME_LIMITATION_ID) : null, - context.getSource().getServer() - ); + List limitations = getLimitationInstance(context, hasID, hasPlayer); ParCoolConfig.Server.Booleans item = LimitationItemArgumentType.getBool(context, ARGS_NAME_CONFIG_ITEM); context.getSource().sendSuccess( new StringTextComponent( @@ -311,11 +315,7 @@ private static int getBoolLimitation(CommandContext context, bool } private static int getIntLimitation(CommandContext context, boolean hasID, boolean hasPlayer) throws CommandSyntaxException { - List limitations = getLimitationInstance( - hasPlayer ? Collections.singletonList(EntityArgument.getPlayer(context, ARGS_NAME_PLAYER)) : Collections.emptyList(), - hasID ? LimitationIDArgumentType.getLimitationID(context, ARGS_NAME_LIMITATION_ID) : null, - context.getSource().getServer() - ); + List limitations = getLimitationInstance(context, hasID, hasPlayer); ParCoolConfig.Server.Integers item = LimitationItemArgumentType.getInt(context, ARGS_NAME_CONFIG_ITEM); context.getSource().sendSuccess( new StringTextComponent( @@ -327,11 +327,7 @@ private static int getIntLimitation(CommandContext context, boole } private static int getDoubleLimitation(CommandContext context, boolean hasID, boolean hasPlayer) throws CommandSyntaxException { - List limitations = getLimitationInstance( - hasPlayer ? Collections.singletonList(EntityArgument.getPlayer(context, ARGS_NAME_PLAYER)) : Collections.emptyList(), - hasID ? LimitationIDArgumentType.getLimitationID(context, ARGS_NAME_LIMITATION_ID) : null, - context.getSource().getServer() - ); + List limitations = getLimitationInstance(context, hasID, hasPlayer); ParCoolConfig.Server.Doubles item = LimitationItemArgumentType.getDouble(context, ARGS_NAME_CONFIG_ITEM); context.getSource().sendSuccess( new StringTextComponent( @@ -343,11 +339,7 @@ private static int getDoubleLimitation(CommandContext context, bo } private static int getActionPossibility(CommandContext context, boolean hasID, boolean hasPlayer) throws CommandSyntaxException { - List limitations = getLimitationInstance( - hasPlayer ? Collections.singletonList(EntityArgument.getPlayer(context, ARGS_NAME_PLAYER)) : Collections.emptyList(), - hasID ? LimitationIDArgumentType.getLimitationID(context, ARGS_NAME_LIMITATION_ID) : null, - context.getSource().getServer() - ); + List limitations = getLimitationInstance(context, hasID, hasPlayer); Class action = ActionArgumentType.getAction(context, ARGS_NAME_ACTION); context.getSource().sendSuccess( new StringTextComponent( @@ -359,11 +351,7 @@ private static int getActionPossibility(CommandContext context, b } private static int getLimitationInfo(CommandContext context, boolean hasID, boolean hasPlayer) throws CommandSyntaxException { - List limitations = getLimitationInstance( - hasPlayer ? Collections.singletonList(EntityArgument.getPlayer(context, ARGS_NAME_PLAYER)) : Collections.emptyList(), - hasID ? LimitationIDArgumentType.getLimitationID(context, ARGS_NAME_LIMITATION_ID) : null, - context.getSource().getServer() - ); + List limitations = getLimitationInstance(context, hasID, hasPlayer); Limitation limitation = limitations.get(0); StringBuilder builder = new StringBuilder(); builder.append("- Limitation Info -\n"); @@ -393,11 +381,7 @@ private static int getLimitationInfo(CommandContext context, bool } private static int getLeastStaminaConsumption(CommandContext context, boolean hasID, boolean hasPlayer) throws CommandSyntaxException { - List limitations = getLimitationInstance( - hasPlayer ? Collections.singletonList(EntityArgument.getPlayer(context, ARGS_NAME_PLAYER)) : Collections.emptyList(), - hasID ? LimitationIDArgumentType.getLimitationID(context, ARGS_NAME_LIMITATION_ID) : null, - context.getSource().getServer() - ); + List limitations = getLimitationInstance(context, hasID, hasPlayer); Class action = ActionArgumentType.getAction(context, ARGS_NAME_ACTION); context.getSource().sendSuccess( new StringTextComponent( @@ -409,11 +393,7 @@ private static int getLeastStaminaConsumption(CommandContext cont } private static int setLimitationDefault(CommandContext context, boolean hasID, boolean hasPlayer) throws CommandSyntaxException { - List limitations = getLimitationInstance( - hasPlayer ? EntityArgument.getPlayers(context, ARGS_NAME_PLAYERS) : Collections.emptyList(), - hasID ? LimitationIDArgumentType.getLimitationID(context, ARGS_NAME_LIMITATION_ID) : null, - context.getSource().getServer() - ); + List limitations = getLimitationInstance(context, hasID, hasPlayer); int num = 0; for (Limitation limitation : limitations) { limitation.setDefault().apply(); @@ -425,11 +405,7 @@ private static int setLimitationDefault(CommandContext context, b } private static int setBoolLimitation(CommandContext context, boolean hasID, boolean hasPlayer) throws CommandSyntaxException { - List limitations = getLimitationInstance( - hasPlayer ? EntityArgument.getPlayers(context, ARGS_NAME_PLAYERS) : Collections.emptyList(), - hasID ? LimitationIDArgumentType.getLimitationID(context, ARGS_NAME_LIMITATION_ID) : null, - context.getSource().getServer() - ); + List limitations = getLimitationInstance(context, hasID, hasPlayer); ParCoolConfig.Server.Booleans item = LimitationItemArgumentType.getBool(context, ARGS_NAME_CONFIG_ITEM); boolean value = BoolArgumentType.getBool(context, ARGS_NAME_VALUE); int num = 0; @@ -443,11 +419,7 @@ private static int setBoolLimitation(CommandContext context, bool } private static int setIntLimitation(CommandContext context, boolean hasID, boolean hasPlayer) throws CommandSyntaxException { - List limitations = getLimitationInstance( - hasPlayer ? EntityArgument.getPlayers(context, ARGS_NAME_PLAYERS) : Collections.emptyList(), - hasID ? LimitationIDArgumentType.getLimitationID(context, ARGS_NAME_LIMITATION_ID) : null, - context.getSource().getServer() - ); + List limitations = getLimitationInstance(context, hasID, hasPlayer); ParCoolConfig.Server.Integers item = LimitationItemArgumentType.getInt(context, ARGS_NAME_CONFIG_ITEM); int value = IntegerArgumentType.getInteger(context, ARGS_NAME_VALUE); if (value < item.Min) { @@ -467,11 +439,7 @@ private static int setIntLimitation(CommandContext context, boole } private static int setDoubleLimitation(CommandContext context, boolean hasID, boolean hasPlayer) throws CommandSyntaxException { - List limitations = getLimitationInstance( - hasPlayer ? EntityArgument.getPlayers(context, ARGS_NAME_PLAYERS) : Collections.emptyList(), - hasID ? LimitationIDArgumentType.getLimitationID(context, ARGS_NAME_LIMITATION_ID) : null, - context.getSource().getServer() - ); + List limitations = getLimitationInstance(context, hasID, hasPlayer); ParCoolConfig.Server.Doubles item = LimitationItemArgumentType.getDouble(context, ARGS_NAME_CONFIG_ITEM); double value = DoubleArgumentType.getDouble(context, ARGS_NAME_VALUE); if (value < item.Min) { @@ -491,11 +459,7 @@ private static int setDoubleLimitation(CommandContext context, bo } private static int enableLimitation(CommandContext context, boolean hasID, boolean hasPlayer) throws CommandSyntaxException { - List limitations = getLimitationInstance( - hasPlayer ? EntityArgument.getPlayers(context, ARGS_NAME_PLAYERS) : Collections.emptyList(), - hasID ? LimitationIDArgumentType.getLimitationID(context, ARGS_NAME_LIMITATION_ID) : null, - context.getSource().getServer() - ); + List limitations = getLimitationInstance(context, hasID, hasPlayer); int num = 0; for (Limitation limitation : limitations) { limitation.enable().apply(); @@ -507,11 +471,7 @@ private static int enableLimitation(CommandContext context, boole } private static int disableLimitation(CommandContext context, boolean hasID, boolean hasPlayer) throws CommandSyntaxException { - List limitations = getLimitationInstance( - hasPlayer ? EntityArgument.getPlayers(context, ARGS_NAME_PLAYERS) : Collections.emptyList(), - hasID ? LimitationIDArgumentType.getLimitationID(context, ARGS_NAME_LIMITATION_ID) : null, - context.getSource().getServer() - ); + List limitations = getLimitationInstance(context, hasID, hasPlayer); int num = 0; for (Limitation limitation : limitations) { limitation.disable().apply(); @@ -525,7 +485,7 @@ private static int disableLimitation(CommandContext context, bool private static int deleteLimitation(CommandContext context) throws CommandSyntaxException { Limitation.ID limitation = LimitationIDArgumentType.getLimitationID(context, ARGS_NAME_LIMITATION_ID); if (Limitation.delete(limitation)) { - for (ServerPlayerEntity player : context.getSource().getServer().getPlayerList().getPlayers()) { + for (ServerPlayerWrapper player : MinecraftServerWrapper.getPlayers(context)) { Limitations.updateOnlyLimitation(player); } context.getSource().sendSuccess(new TranslationTextComponent("parcool.command.message.success.deleteLimitation", limitation.toString()), true); @@ -536,11 +496,7 @@ private static int deleteLimitation(CommandContext context) throw } private static int changeStaminaConsumption(CommandContext context, boolean hasID, boolean hasPlayer) throws CommandSyntaxException { - List limitations = getLimitationInstance( - hasPlayer ? EntityArgument.getPlayers(context, ARGS_NAME_PLAYERS) : Collections.emptyList(), - hasID ? LimitationIDArgumentType.getLimitationID(context, ARGS_NAME_LIMITATION_ID) : null, - context.getSource().getServer() - ); + List limitations = getLimitationInstance(context, hasID, hasPlayer); Class action = ActionArgumentType.getAction(context, ARGS_NAME_ACTION); int newValue = IntegerArgumentType.getInteger(context, ARGS_NAME_STAMINA_CONSUMPTION); int num = 0; @@ -554,11 +510,7 @@ private static int changeStaminaConsumption(CommandContext contex } private static int changePossibilityOfAction(CommandContext context, boolean hasID, boolean hasPlayer) throws CommandSyntaxException { - List limitations = getLimitationInstance( - hasPlayer ? EntityArgument.getPlayers(context, ARGS_NAME_PLAYERS) : Collections.emptyList(), - hasID ? LimitationIDArgumentType.getLimitationID(context, ARGS_NAME_LIMITATION_ID) : null, - context.getSource().getServer() - ); + List limitations = getLimitationInstance(context, hasID, hasPlayer); Class action = ActionArgumentType.getAction(context, ARGS_NAME_ACTION); boolean newValue = BoolArgumentType.getBool(context, ARGS_NAME_POSSIBILITY); int num = 0; diff --git a/src/main/java/com/alrex/parcool/server/limitation/Limitations.java b/src/main/java/com/alrex/parcool/server/limitation/Limitations.java index 4cc50bbf..aa449aa7 100644 --- a/src/main/java/com/alrex/parcool/server/limitation/Limitations.java +++ b/src/main/java/com/alrex/parcool/server/limitation/Limitations.java @@ -1,24 +1,21 @@ package com.alrex.parcool.server.limitation; import com.alrex.parcool.ParCool; +import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ServerLimitation; import com.alrex.parcool.common.network.SyncServerInfoMessage; +import com.alrex.parcool.utilities.JsonWriterUtil; import com.alrex.parcool.utilities.ServerUtil; import com.google.gson.stream.JsonReader; -import com.google.gson.stream.JsonWriter; -import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraftforge.fml.event.server.FMLServerAboutToStartEvent; import net.minecraftforge.fml.event.server.FMLServerStoppingEvent; import org.apache.commons.io.FileUtils; - import javax.annotation.Nullable; import java.io.*; import java.nio.charset.StandardCharsets; -import java.nio.file.Files; import java.nio.file.Path; -import java.nio.file.StandardOpenOption; import java.util.*; public class Limitations { @@ -80,7 +77,7 @@ public static Limitation getLimitationOf(UUID playerID, Limitation.ID id) { return getLimitationMapOf(playerID).get(id); } - public static void update(ServerPlayerEntity player) { + public static void update(ServerPlayerWrapper player) { Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; parkourability.getActionInfo().setServerLimitation(ServerLimitation.get(player)); @@ -92,7 +89,7 @@ public static void update(ServerPlayerEntity player) { } } - public static void updateOnlyLimitation(ServerPlayerEntity player) { + public static void updateOnlyLimitation(ServerPlayerWrapper player) { Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; parkourability.getActionInfo().setServerLimitation(ServerLimitation.get(player)); @@ -178,23 +175,7 @@ public static void unload(UUID playerID) { if (!limitationFile.getParentFile().exists()) { limitationFile.getParentFile().mkdirs(); } - try (JsonWriter writer = - new JsonWriter( - new OutputStreamWriter( - new BufferedOutputStream( - Files.newOutputStream(limitationFile.toPath(), StandardOpenOption.CREATE, StandardOpenOption.WRITE) - ), - StandardCharsets.UTF_8 - ) - ) - ) { - limitation.saveTo(writer); - } catch (IOException e) { - ParCool.LOGGER.error( - "IOException during saving limitation : " - + e.getMessage() - ); - } + JsonWriterUtil.Save(limitation, limitationFile); } ParCool.LOGGER.info("Limitation of " + playerID + " was unloaded"); } @@ -220,23 +201,7 @@ public static void save(FMLServerStoppingEvent event) { if (!limitationFile.getParentFile().exists()) { limitationFile.getParentFile().mkdirs(); } - try (JsonWriter writer = - new JsonWriter( - new OutputStreamWriter( - new BufferedOutputStream( - Files.newOutputStream(limitationFile.toPath(), StandardOpenOption.CREATE, StandardOpenOption.WRITE) - ), - StandardCharsets.UTF_8 - ) - ) - ) { - limitation.saveTo(writer); - } catch (IOException e) { - ParCool.LOGGER.error( - "IOException during saving limitation : " - + e.getMessage() - ); - } + JsonWriterUtil.Save(limitation, limitationFile); } } } diff --git a/src/main/java/com/alrex/parcool/utilities/BipedModelUtil.java b/src/main/java/com/alrex/parcool/utilities/BipedModelUtil.java index 3b2d3947..f23ee6de 100644 --- a/src/main/java/com/alrex/parcool/utilities/BipedModelUtil.java +++ b/src/main/java/com/alrex/parcool/utilities/BipedModelUtil.java @@ -1,12 +1,11 @@ package com.alrex.parcool.utilities; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.util.Hand; +import com.alrex.parcool.api.compatibility.PlayerWrapper; import net.minecraft.util.HandSide; public class BipedModelUtil { - public static HandSide getAttackArm(PlayerEntity player) { + public static HandSide getAttackArm(PlayerWrapper player) { HandSide handside = player.getMainArm(); - return player.swingingArm == Hand.MAIN_HAND ? handside : handside.getOpposite(); + return player.isSwingingMainHand() ? handside : handside.getOpposite(); } } diff --git a/src/main/java/com/alrex/parcool/utilities/EntityUtil.java b/src/main/java/com/alrex/parcool/utilities/EntityUtil.java index cfa13135..aa786e04 100644 --- a/src/main/java/com/alrex/parcool/utilities/EntityUtil.java +++ b/src/main/java/com/alrex/parcool/utilities/EntityUtil.java @@ -1,10 +1,10 @@ package com.alrex.parcool.utilities; -import net.minecraft.entity.Entity; +import com.alrex.parcool.api.compatibility.EntityWrapper; import net.minecraft.util.math.vector.Vector3d; public class EntityUtil { - public static void addVelocity(Entity entity, Vector3d vec) { - entity.setDeltaMovement(entity.getDeltaMovement().add(vec)); + public static void addVelocity(EntityWrapper entity, Vector3d vec) { + entity.addToDeltaMovement(vec); } } diff --git a/src/main/java/com/alrex/parcool/utilities/JsonWriterUtil.java b/src/main/java/com/alrex/parcool/utilities/JsonWriterUtil.java new file mode 100644 index 00000000..42dbb8a9 --- /dev/null +++ b/src/main/java/com/alrex/parcool/utilities/JsonWriterUtil.java @@ -0,0 +1,38 @@ +package com.alrex.parcool.utilities; + +import java.io.BufferedOutputStream; +import java.io.File; +import java.io.IOException; +import java.io.OutputStreamWriter; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.StandardOpenOption; + +import com.alrex.parcool.ParCool; +import com.alrex.parcool.server.limitation.Limitation; +import com.google.gson.stream.JsonWriter; + +public class JsonWriterUtil { + public static JsonWriter GetJsonWriter(File file) throws IOException { + return new JsonWriter( + new OutputStreamWriter( + new BufferedOutputStream( + Files.newOutputStream(file.toPath(), StandardOpenOption.CREATE, StandardOpenOption.WRITE) + ), + StandardCharsets.UTF_8 + ) + ); + } + + public static void Save(Limitation limitation, File limitationFile) { + try (JsonWriter writer = JsonWriterUtil.GetJsonWriter(limitationFile) + ) { + limitation.saveTo(writer); + } catch (IOException e) { + ParCool.LOGGER.error( + "IOException during saving limitation : " + + e.getMessage() + ); + } + } +} diff --git a/src/main/java/com/alrex/parcool/utilities/WorldUtil.java b/src/main/java/com/alrex/parcool/utilities/WorldUtil.java index ea0261cc..7f38fbf0 100644 --- a/src/main/java/com/alrex/parcool/utilities/WorldUtil.java +++ b/src/main/java/com/alrex/parcool/utilities/WorldUtil.java @@ -1,10 +1,10 @@ package com.alrex.parcool.utilities; +import com.alrex.parcool.api.compatibility.EntityWrapper; +import com.alrex.parcool.api.compatibility.LivingEntityWrapper; import com.alrex.parcool.common.action.impl.HangDown; import com.alrex.parcool.common.tags.BlockTags; import net.minecraft.block.*; -import net.minecraft.entity.Entity; -import net.minecraft.entity.LivingEntity; import net.minecraft.state.properties.Half; import net.minecraft.util.Direction; import net.minecraft.util.Tuple; @@ -17,7 +17,7 @@ public class WorldUtil { - public static Vector3d getRunnableWall(LivingEntity entity, double range) { + public static Vector3d getRunnableWall(LivingEntityWrapper entity, double range) { double width = entity.getBbWidth() * 0.4f; double wallX = 0; double wallZ = 0; @@ -40,23 +40,23 @@ public static Vector3d getRunnableWall(LivingEntity entity, double range) { pos.z() + width ); - if (!entity.level.noCollision(baseBox1.expandTowards(range, 0, 0)) - && !entity.level.noCollision(baseBox2.expandTowards(range, 0, 0)) + if (!entity.noCollision(baseBox1.expandTowards(range, 0, 0)) + && !entity.noCollision(baseBox2.expandTowards(range, 0, 0)) ) { wallX++; } - if (!entity.level.noCollision(baseBox1.expandTowards(-range, 0, 0)) - && !entity.level.noCollision(baseBox2.expandTowards(-range, 0, 0)) + if (!entity.noCollision(baseBox1.expandTowards(-range, 0, 0)) + && !entity.noCollision(baseBox2.expandTowards(-range, 0, 0)) ) { wallX--; } - if (!entity.level.noCollision(baseBox1.expandTowards(0, 0, range)) - && !entity.level.noCollision(baseBox2.expandTowards(0, 0, range)) + if (!entity.noCollision(baseBox1.expandTowards(0, 0, range)) + && !entity.noCollision(baseBox2.expandTowards(0, 0, range)) ) { wallZ++; } - if (!entity.level.noCollision(baseBox1.expandTowards(0, 0, -range)) - && !entity.level.noCollision(baseBox1.expandTowards(0, 0, -range)) + if (!entity.noCollision(baseBox1.expandTowards(0, 0, -range)) + && !entity.noCollision(baseBox1.expandTowards(0, 0, -range)) ) { wallZ--; } @@ -66,11 +66,11 @@ public static Vector3d getRunnableWall(LivingEntity entity, double range) { } @Nullable - public static Vector3d getWall(LivingEntity entity) { + public static Vector3d getWall(LivingEntityWrapper entity) { return getWall(entity, entity.getBbWidth() * 0.5); } @Nullable - public static Vector3d getWall(LivingEntity entity, double range) { + public static Vector3d getWall(LivingEntityWrapper entity, double range) { final double width = entity.getBbWidth() * 0.49; double wallX = 0; double wallZ = 0; @@ -85,16 +85,16 @@ public static Vector3d getWall(LivingEntity entity, double range) { pos.z() + width ); - if (!entity.level.noCollision(baseBox.expandTowards(range, 0, 0))) { + if (!entity.noCollision(baseBox.expandTowards(range, 0, 0))) { wallX++; } - if (!entity.level.noCollision(baseBox.expandTowards(-range, 0, 0))) { + if (!entity.noCollision(baseBox.expandTowards(-range, 0, 0))) { wallX--; } - if (!entity.level.noCollision(baseBox.expandTowards(0, 0, range))) { + if (!entity.noCollision(baseBox.expandTowards(0, 0, range))) { wallZ++; } - if (!entity.level.noCollision(baseBox.expandTowards(0, 0, -range))) { + if (!entity.noCollision(baseBox.expandTowards(0, 0, -range))) { wallZ--; } if (wallX == 0 && wallZ == 0) return null; @@ -103,9 +103,9 @@ public static Vector3d getWall(LivingEntity entity, double range) { } @Nullable - public static Vector3d getVaultableStep(LivingEntity entity) { + public static Vector3d getVaultableStep(LivingEntityWrapper entity) { final double d = entity.getBbWidth() * 0.5; - World world = entity.level; + World world = entity.getLevel(); double distance = entity.getBbWidth() / 2; double baseLine = Math.min(entity.getBbHeight() * 0.86, getWallHeight(entity)); double stepX = 0; @@ -160,10 +160,10 @@ public static Vector3d getVaultableStep(LivingEntity entity) { return new Vector3d(stepX, 0, stepZ); } - public static double getWallHeight(LivingEntity entity, Vector3d direction, double maxHeight, double accuracy) { + public static double getWallHeight(LivingEntityWrapper entity, Vector3d direction, double maxHeight, double accuracy) { final double d = entity.getBbWidth() * 0.49; direction = direction.normalize(); - World world = entity.level; + World world = entity.getLevel(); Vector3d pos = entity.position(); boolean canReturn = false; for (double height = 0; height < maxHeight; height += accuracy) { @@ -186,10 +186,10 @@ public static double getWallHeight(LivingEntity entity, Vector3d direction, doub return maxHeight; } - public static double getWallHeight(LivingEntity entity) { + public static double getWallHeight(LivingEntityWrapper entity) { Vector3d wall = getWall(entity); if (wall == null) return 0; - World world = entity.level; + World world = entity.getLevel(); final double accuracy = entity.getBbHeight() / 18; // normally about 0.1 final double d = entity.getBbWidth() * 0.5; int loopNum = (int) Math.round(entity.getBbHeight() / accuracy); @@ -215,29 +215,32 @@ public static double getWallHeight(LivingEntity entity) { } @Nullable - public static HangDown.BarAxis getHangableBars(LivingEntity entity) { + public static HangDown.BarAxis getHangableBars(LivingEntityWrapper entity) { final double bbWidth = entity.getBbWidth() / 4; final double bbHeight = 0.35; + double x = entity.getX(); + double y = entity.getY(); + double z = entity.getZ(); AxisAlignedBB bb = new AxisAlignedBB( - entity.getX() - bbWidth, - entity.getY() + entity.getBbHeight(), - entity.getZ() - bbWidth, - entity.getX() + bbWidth, - entity.getY() + entity.getBbHeight() + bbHeight, - entity.getZ() + bbWidth + x - bbWidth, + y + entity.getBbHeight(), + z - bbWidth, + x + bbWidth, + y + entity.getBbHeight() + bbHeight, + z + bbWidth ); - if (entity.level.noCollision(bb)) return null; + if (entity.noCollision(bb)) return null; BlockPos pos = new BlockPos( - entity.getX(), - entity.getY() + entity.getBbHeight() + 0.4, - entity.getZ() + x, + y + entity.getBbHeight() + 0.4, + z ); - if (!entity.level.isLoaded(pos)) return null; - BlockState state = entity.level.getBlockState(pos); + if (!entity.isEveryLoaded(pos)) return null; + BlockState state = entity.getBlockState(pos); Block block = state.getBlock(); HangDown.BarAxis axis = null; if (block instanceof RotatedPillarBlock) { - if (state.isCollisionShapeFullBlock(entity.level, pos)) { + if (state.isCollisionShapeFullBlock(entity.getLevel(), pos)) { return null; } Direction.Axis pillarAxis = state.getValue(RotatedPillarBlock.AXIS); @@ -250,7 +253,7 @@ public static HangDown.BarAxis getHangableBars(LivingEntity entity) { break; } } else if (block instanceof DirectionalBlock) { - if (state.isCollisionShapeFullBlock(entity.level, pos)) { + if (state.isCollisionShapeFullBlock(entity.getLevel(), pos)) { return null; } Direction direction = state.getValue(DirectionalBlock.FACING); @@ -286,8 +289,8 @@ public static HangDown.BarAxis getHangableBars(LivingEntity entity) { return axis; } - public static boolean existsSpaceBelow(LivingEntity entity) { - World world = entity.level; + public static boolean existsSpaceBelow(LivingEntityWrapper entity) { + World world = entity.getLevel(); Vector3d center = entity.position(); if (!world.isLoaded(new BlockPos(center))) return false; double height = entity.getBbHeight() * 1.5; @@ -302,8 +305,8 @@ public static boolean existsSpaceBelow(LivingEntity entity) { ); return world.noCollision(boundingBox); } - public static boolean existsDivableSpace(LivingEntity entity) { - World world = entity.level; + public static boolean existsDivableSpace(LivingEntityWrapper entity) { + World world = entity.getLevel(); double width = entity.getBbWidth() * 1.5; double height = entity.getBbHeight() * 1.5; double wideWidth = entity.getBbWidth() * 2; @@ -368,9 +371,9 @@ public static boolean existsDivableSpace(LivingEntity entity) { } @Nullable - public static Vector3d getGrabbableWall(LivingEntity entity) { + public static Vector3d getGrabbableWall(LivingEntityWrapper entity) { final double d = entity.getBbWidth() * 0.5; - World world = entity.level; + World world = entity.getLevel(); double distance = entity.getBbWidth() / 2; double baseLine1 = entity.getEyeHeight() + (entity.getBbHeight() - entity.getEyeHeight()) / 2; double baseLine2 = entity.getBbHeight() + (entity.getBbHeight() - entity.getEyeHeight()) / 2; @@ -379,9 +382,9 @@ public static Vector3d getGrabbableWall(LivingEntity entity) { return getGrabbableWall(entity, distance, baseLine2); } - private static Vector3d getGrabbableWall(LivingEntity entity, double distance, double baseLine) { + private static Vector3d getGrabbableWall(LivingEntityWrapper entity, double distance, double baseLine) { final double d = entity.getBbWidth() * 0.49; - World world = entity.level; + World world = entity.getLevel(); Vector3d pos = entity.position(); AxisAlignedBB baseBoxSide = new AxisAlignedBB( pos.x() - d, @@ -415,30 +418,26 @@ private static Vector3d getGrabbableWall(LivingEntity entity, double distance, d } float slipperiness; if (xDirection != 0 && zDirection != 0) { - BlockPos blockPos1 = new BlockPos( - entity.getX() + xDirection, - entity.getBoundingBox().minY + baseLine - 0.3, - entity.getZ() + BlockPos blockPos1 = entity.getAdjustedBlockPos( + xDirection, + baseLine - 0.3, + 0 ); - BlockPos blockPos2 = new BlockPos( - entity.getX(), - entity.getBoundingBox().minY + baseLine - 0.3, - entity.getZ() + zDirection - ); - if (!entity.level.isLoaded(blockPos1)) return null; - if (!entity.level.isLoaded(blockPos2)) return null; - slipperiness = Math.min( - entity.level.getBlockState(blockPos1).getSlipperiness(entity.level, blockPos1, entity), - entity.level.getBlockState(blockPos2).getSlipperiness(entity.level, blockPos2, entity) + BlockPos blockPos2 = entity.getAdjustedBlockPos( + 0, + baseLine - 0.3, + zDirection ); + if (!entity.isEveryLoaded(blockPos1, blockPos2)) return null; + slipperiness = entity.getMinSlipperiness(blockPos1, blockPos2); } else { - BlockPos blockPos = new BlockPos( - entity.getX() + xDirection, - entity.getBoundingBox().minY + baseLine - 0.3, - entity.getZ() + zDirection + BlockPos blockPos = entity.getAdjustedBlockPos( + xDirection, + baseLine - 0.3, + zDirection ); - if (!entity.level.isLoaded(blockPos)) return null; - slipperiness = entity.level.getBlockState(blockPos).getSlipperiness(entity.level, blockPos, entity); + if (!entity.isEveryLoaded(blockPos)) return null; + slipperiness = entity.getMinSlipperiness(blockPos); } return slipperiness <= 0.9 ? new Vector3d(xDirection, 0, zDirection) : null; } @@ -452,8 +451,8 @@ public static boolean isHideAbleBlock(BlockState blockState) { } @Nullable - public static Tuple getHideAbleSpace(Entity entity, BlockPos base) { - World world = entity.level; + public static Tuple getHideAbleSpace(EntityWrapper entity, BlockPos base) { + World world = entity.getLevel(); if (!world.isLoaded(base)) return null; BlockState state = world.getBlockState(base); Block block = state.getBlock(); From 53dc4c6492a0fc11cde3bbc21bc756c0023c9086 Mon Sep 17 00:00:00 2001 From: Thiago Santos Date: Thu, 1 May 2025 17:47:33 -0300 Subject: [PATCH 2/8] feat: wrapping Vector3d --- .../api/compatibility/AxisWrapper.java | 52 +++++++++++++++ .../api/compatibility/EntityWrapper.java | 15 ++--- .../compatibility/LivingEntityWrapper.java | 8 +-- .../api/compatibility/PlayerWrapper.java | 9 +-- .../api/compatibility/Vec3Wrapper.java | 66 +++++++++++++++++++ .../animation/PassiveCustomAnimation.java | 4 +- .../client/animation/PlayerModelRotator.java | 13 ++-- .../animation/impl/FastRunningAnimator.java | 10 +-- .../animation/impl/FastSwimAnimator.java | 10 +-- .../animation/impl/HideInBlockAnimator.java | 4 +- .../animation/impl/RideZiplineAnimator.java | 16 ++--- .../animation/impl/SlidingAnimator.java | 4 +- .../animation/impl/WallSlideAnimator.java | 12 ++-- .../renderer/entity/ZiplineRopeRenderer.java | 32 ++++----- .../common/action/BehaviorEnforcer.java | 16 +++-- .../common/action/impl/BreakfallReady.java | 4 +- .../parcool/common/action/impl/CatLeap.java | 18 ++--- .../common/action/impl/ChargeJump.java | 6 +- .../parcool/common/action/impl/ClimbUp.java | 4 +- .../common/action/impl/ClingToCliff.java | 18 ++--- .../parcool/common/action/impl/Dodge.java | 6 +- .../parcool/common/action/impl/HangDown.java | 18 ++--- .../common/action/impl/HideInBlock.java | 30 ++++----- .../common/action/impl/HorizontalWallRun.java | 54 +++++++-------- .../parcool/common/action/impl/QuickTurn.java | 10 +-- .../common/action/impl/RideZipline.java | 32 ++++----- .../parcool/common/action/impl/Roll.java | 4 +- .../parcool/common/action/impl/SkyDive.java | 6 +- .../parcool/common/action/impl/Slide.java | 22 +++---- .../parcool/common/action/impl/Vault.java | 16 ++--- .../common/action/impl/VerticalWallRun.java | 22 +++---- .../parcool/common/action/impl/WallJump.java | 56 ++++++++-------- .../parcool/common/action/impl/WallSlide.java | 18 ++--- .../block/zipline/IronZiplineHookBlock.java | 8 +-- .../block/zipline/ZiplineHookBlock.java | 6 +- .../block/zipline/ZiplineHookTileEntity.java | 8 +-- .../entity/zipline/ZiplineRopeEntity.java | 12 ++-- .../alrex/parcool/common/zipline/Zipline.java | 30 ++++----- .../parcool/common/zipline/ZiplineType.java | 4 +- .../impl/GeneralQuadraticCurveZipline.java | 16 ++--- .../zipline/impl/QuadraticCurveZipline.java | 18 ++--- .../common/zipline/impl/StraightZipline.java | 20 +++--- .../mixin/client/ClientPlayerEntityMixin.java | 10 +-- .../alrex/parcool/utilities/BufferUtil.java | 9 +-- .../alrex/parcool/utilities/EntityUtil.java | 4 +- .../alrex/parcool/utilities/VectorUtil.java | 12 ++-- .../alrex/parcool/utilities/WorldUtil.java | 52 +++++++-------- 47 files changed, 473 insertions(+), 351 deletions(-) create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/AxisWrapper.java create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/Vec3Wrapper.java diff --git a/src/main/java/com/alrex/parcool/api/compatibility/AxisWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/AxisWrapper.java new file mode 100644 index 00000000..58e556f3 --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/AxisWrapper.java @@ -0,0 +1,52 @@ +package com.alrex.parcool.api.compatibility; + +import net.minecraft.util.math.vector.Quaternion; +import net.minecraft.util.math.vector.Vector3f; + +public final class AxisWrapper { + public static AxisWrapper XN = new AxisWrapper(Vector3f.XN); + public static AxisWrapper XP = new AxisWrapper(Vector3f.XP); + public static AxisWrapper YN = new AxisWrapper(Vector3f.YN); + public static AxisWrapper YP = new AxisWrapper(Vector3f.YP); + public static AxisWrapper ZN = new AxisWrapper(Vector3f.ZN); + public static AxisWrapper ZP = new AxisWrapper(Vector3f.ZP); + private Vector3f vector; + + public static AxisWrapper createXZ(Vec3Wrapper vec) { + return new AxisWrapper(vec.x(), 0, vec.z()); + } + + public AxisWrapper(Vector3f vec) { + vector = vec; + } + public AxisWrapper(float x, float y, float z) { + vector = new Vector3f(x, y, z); + } + public AxisWrapper(double x, double y, double z) { + vector = new Vector3f((float)x, (float)y, (float)z); + } + + public Quaternion rotationDegrees(float angleDegree) { + return vector.rotationDegrees(angleDegree); + } + + public Quaternion rotation(float angle) { + return vector.rotation(angle); + } + + public static AxisWrapper fromVector(Vec3Wrapper midPointD) { + return new AxisWrapper(midPointD.x(), midPointD.y(), midPointD.z()); + } + + public float x() { + return vector.x(); + } + + public float y() { + return vector.y(); + } + + public float z() { + return vector.z(); + } +} diff --git a/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java index ef8f34ea..9ee1d2e1 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java +++ b/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java @@ -12,7 +12,6 @@ import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.MathHelper; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.World; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.common.util.LazyOptional; @@ -40,7 +39,7 @@ public void addToDeltaMovement(int i, double d, int j) { entity.setDeltaMovement(entity.getDeltaMovement().add(i, d, j)); } - public void addToDeltaMovement(Vector3d vec) { + public void addToDeltaMovement(Vec3Wrapper vec) { entity.setDeltaMovement(entity.getDeltaMovement().add(vec)); } @@ -69,8 +68,8 @@ public LazyOptional getCapability(@Nonnull final Capability cap) { return entity.getCapability(cap); } - public Vector3d getDeltaMovement() { - return entity.getDeltaMovement(); + public Vec3Wrapper getDeltaMovement() { + return new Vec3Wrapper(entity.getDeltaMovement()); } public float getEyeHeight() { @@ -85,8 +84,8 @@ public World getLevel() { return entity.level; } - public Vector3d getLookAngle() { - return entity.getLookAngle(); + public Vec3Wrapper getLookAngle() { + return new Vec3Wrapper(entity.getLookAngle()); } public float getMinSlipperiness(BlockPos ...blockPos) { @@ -183,8 +182,8 @@ public void playSound(SoundEvent soundEvent, float i, float j) { entity.playSound(soundEvent, i, j); } - public Vector3d position() { - return entity.position(); + public Vec3Wrapper position() { + return new Vec3Wrapper(entity.position()); } public void resetFallDistance() { diff --git a/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java index 6f4d47b1..45099175 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java +++ b/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java @@ -64,8 +64,8 @@ public Random getRandom() { return entity.getRandom(); } - public Vector3d getRotatedBodyAngle(PlayerModelRotator rotator) { - return VectorUtil.fromYawDegree(MathUtil.lerp(entity.yBodyRotO, entity.yBodyRot, rotator.getPartialTick())); + public Vec3Wrapper getRotatedBodyAngle(PlayerModelRotator rotator) { + return new Vec3Wrapper(VectorUtil.fromYawDegree(MathUtil.lerp(entity.yBodyRotO, entity.yBodyRot, rotator.getPartialTick()))); } public double getUpdatedYRotDifference() { @@ -77,8 +77,8 @@ public double getUpdatedYRotDifference() { ); } - public Vector3d getVectorYBodyRot() { - return VectorUtil.fromYawDegree(entity.yBodyRot); + public Vec3Wrapper getVectorYBodyRot() { + return new Vec3Wrapper(VectorUtil.fromYawDegree(entity.yBodyRot)); } public float getYBodyRot() { diff --git a/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java index dddb6977..d861ae2b 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java +++ b/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java @@ -14,7 +14,6 @@ import net.minecraft.entity.LivingEntity; import net.minecraft.entity.Pose; import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.item.BlockItemUseContext; import net.minecraft.item.ItemStack; import net.minecraft.item.ItemUseContext; import net.minecraft.potion.Effect; @@ -22,7 +21,6 @@ import net.minecraft.util.Hand; import net.minecraft.util.SoundEvent; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.util.text.IFormattableTextComponent; import net.minecraft.world.World; import net.minecraftforge.common.capabilities.Capability; @@ -31,7 +29,6 @@ import net.minecraftforge.event.AttachCapabilitiesEvent; import net.minecraftforge.event.TickEvent.PlayerTickEvent; import net.minecraftforge.event.entity.living.LivingEvent; -import net.minecraftforge.event.entity.living.LivingEvent.LivingJumpEvent; import net.minecraftforge.event.entity.living.LivingFallEvent; import net.minecraftforge.event.entity.player.PlayerEvent; import net.minecraftforge.event.entity.player.PlayerEvent.Clone; @@ -273,11 +270,11 @@ public void setAllYBodyRot(float bodyYaw) { player.yBodyRotO = bodyYaw; } - public void setDeltaMovement(Vector3d vec) { + public void setDeltaMovement(Vec3Wrapper vec) { player.setDeltaMovement(vec); } - public void setPos(Vector3d hidingPoint) { + public void setPos(Vec3Wrapper hidingPoint) { player.setPos(hidingPoint.x(), hidingPoint.y(), hidingPoint.z()); } @@ -345,7 +342,7 @@ public void playSound(SoundEvent soundEvent, float i, float j) { player.playSound(soundEvent, i, j); } - public void rotateBodyRot0(Vector3d direction, double d) { + public void rotateBodyRot0(Vec3Wrapper direction, double d) { player.yBodyRotO = player.yBodyRot = (float) VectorUtil.toYawDegree(direction.yRot((float) d)); } } diff --git a/src/main/java/com/alrex/parcool/api/compatibility/Vec3Wrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/Vec3Wrapper.java new file mode 100644 index 00000000..1b23de97 --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/Vec3Wrapper.java @@ -0,0 +1,66 @@ +package com.alrex.parcool.api.compatibility; + +import com.alrex.parcool.utilities.VectorUtil; +import net.minecraft.util.math.vector.Vector3d; + +public class Vec3Wrapper extends Vector3d { + public static final Vec3Wrapper ZERO = new Vec3Wrapper(Vector3d.ZERO); + + public Vec3Wrapper(double x, double y, double z) { + super(x, y, z); + } + + public Vec3Wrapper(Vector3d vec) { + super(vec.x, vec.y, vec.z); + } + + @Override + public Vec3Wrapper normalize() { + return new Vec3Wrapper(super.normalize()); + } + + @Override + public Vec3Wrapper scale(double scale) { + return new Vec3Wrapper(super.scale(scale)); + } + + @Override + public Vec3Wrapper subtract(Vector3d vec) { + return new Vec3Wrapper(super.subtract(vec)); + } + + @Override + public Vec3Wrapper subtract(double x, double y, double z) { + return new Vec3Wrapper(super.subtract(x, y, z)); + } + + @Override + public Vec3Wrapper add(Vector3d vec) { + return new Vec3Wrapper(super.add(vec)); + } + + @Override + public Vec3Wrapper add(double x, double y, double z) { + return new Vec3Wrapper(super.add(x, y, z)); + } + + @Override + public Vec3Wrapper multiply(double x, double y, double z) { + return new Vec3Wrapper(super.multiply(x, y, z)); + } + + @Override + public Vec3Wrapper multiply(Vector3d vec) { + return new Vec3Wrapper(super.multiply(vec)); + } + + @Override + public Vec3Wrapper yRot(float value) { + return new Vec3Wrapper(super.yRot(value)); + } + + @Override + public Vec3Wrapper reverse() { + return new Vec3Wrapper(super.reverse()); + } +} diff --git a/src/main/java/com/alrex/parcool/client/animation/PassiveCustomAnimation.java b/src/main/java/com/alrex/parcool/client/animation/PassiveCustomAnimation.java index 821c440f..0baf2f1a 100644 --- a/src/main/java/com/alrex/parcool/client/animation/PassiveCustomAnimation.java +++ b/src/main/java/com/alrex/parcool/client/animation/PassiveCustomAnimation.java @@ -1,6 +1,7 @@ package com.alrex.parcool.client.animation; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.impl.ClingToCliff; import com.alrex.parcool.common.action.impl.Dive; @@ -10,7 +11,6 @@ import com.alrex.parcool.utilities.MathUtil; import com.alrex.parcool.utilities.VectorUtil; import net.minecraft.particles.ParticleTypes; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.World; import java.util.Random; @@ -110,7 +110,7 @@ private void rotateCreativeFlying(PlayerWrapper player, PlayerModelRotator rotat private void spawnSweatParticle(PlayerWrapper player) { World level = player.getLevel(); Random rand = player.getRandom(); - Vector3d particleSpeed = player.getDeltaMovement().scale(0.6); + Vec3Wrapper particleSpeed = player.getDeltaMovement().scale(0.6); level.addParticle( ParticleTypes.DRIPPING_WATER, player.getX() + player.getBbWidth() * (rand.nextFloat() - 0.5f), diff --git a/src/main/java/com/alrex/parcool/client/animation/PlayerModelRotator.java b/src/main/java/com/alrex/parcool/client/animation/PlayerModelRotator.java index 10765799..c7b1242f 100644 --- a/src/main/java/com/alrex/parcool/client/animation/PlayerModelRotator.java +++ b/src/main/java/com/alrex/parcool/client/animation/PlayerModelRotator.java @@ -1,9 +1,10 @@ package com.alrex.parcool.client.animation; +import com.alrex.parcool.api.compatibility.AxisWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.api.unstable.animation.AnimationOption; import com.mojang.blaze3d.matrix.MatrixStack; -import net.minecraft.util.math.vector.Vector3f; public class PlayerModelRotator { private final MatrixStack stack; @@ -82,26 +83,26 @@ public PlayerModelRotator translate(float offsetX, float offsetY, float offsetZ) } public PlayerModelRotator rotatePitchFrontward(float angleDegree) { - stack.mulPose(Vector3f.XN.rotationDegrees(angleDegree)); + stack.mulPose(AxisWrapper.XN.rotationDegrees(angleDegree)); return this; } public PlayerModelRotator rotateRollRightward(float angleDegree) { - stack.mulPose(Vector3f.ZN.rotationDegrees(angleDegree)); + stack.mulPose(AxisWrapper.ZN.rotationDegrees(angleDegree)); return this; } public PlayerModelRotator rotateYawRightward(float angleDegree) { - stack.mulPose(Vector3f.YN.rotationDegrees(angleDegree)); + stack.mulPose(AxisWrapper.YN.rotationDegrees(angleDegree)); return this; } - public PlayerModelRotator rotate(float angle, Vector3f axis) { + public PlayerModelRotator rotate(float angle, AxisWrapper axis) { stack.mulPose(axis.rotation(angle)); return this; } - public PlayerModelRotator rotateDegrees(float angleDegree, Vector3f axis) { + public PlayerModelRotator rotateDegrees(float angleDegree, AxisWrapper axis) { stack.mulPose(axis.rotationDegrees(angleDegree)); return this; } diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/FastRunningAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/FastRunningAnimator.java index 15b4a530..c559f294 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/FastRunningAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/FastRunningAnimator.java @@ -1,6 +1,7 @@ package com.alrex.parcool.client.animation.impl; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -12,7 +13,6 @@ import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.entity.model.BipedModel; import net.minecraft.util.HandSide; -import net.minecraft.util.math.vector.Vector3d; public class FastRunningAnimator extends Animator { @Override @@ -141,10 +141,10 @@ public void rotatePost(PlayerWrapper player, Parkourability parkourability, Play .rotatePitchFrontward(pitch) .end(); } else { - Vector3d lookAngle = player.getLookAngle(); - Vector3d bodyAngle = player.getRotatedBodyAngle(rotator); - Vector3d differenceVec = - new Vector3d( + Vec3Wrapper lookAngle = player.getLookAngle(); + Vec3Wrapper bodyAngle = player.getRotatedBodyAngle(rotator); + Vec3Wrapper differenceVec = + new Vec3Wrapper( lookAngle.x() * bodyAngle.x() + lookAngle.z() * bodyAngle.z(), 0, -lookAngle.x() * bodyAngle.z() + lookAngle.z() * bodyAngle.x() ).normalize(); diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/FastSwimAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/FastSwimAnimator.java index c5bae503..4bcc9330 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/FastSwimAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/FastSwimAnimator.java @@ -1,6 +1,7 @@ package com.alrex.parcool.client.animation.impl; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -10,7 +11,6 @@ import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.entity.model.BipedModel; import net.minecraft.util.HandSide; -import net.minecraft.util.math.vector.Vector3d; public class FastSwimAnimator extends Animator { @Override @@ -87,10 +87,10 @@ public void rotatePost(PlayerWrapper player, Parkourability parkourability, Play return; } float tick = getTick() + rotator.getPartialTick(); - Vector3d lookAngle = player.getLookAngle(); - Vector3d bodyAngle = player.getRotatedBodyAngle(rotator); - Vector3d differenceVec = - new Vector3d( + Vec3Wrapper lookAngle = player.getLookAngle(); + Vec3Wrapper bodyAngle = player.getRotatedBodyAngle(rotator); + Vec3Wrapper differenceVec = + new Vec3Wrapper( lookAngle.x() * bodyAngle.x() + lookAngle.z() * bodyAngle.z(), 0, -lookAngle.x() * bodyAngle.z() + lookAngle.z() * bodyAngle.x() ).normalize(); diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/HideInBlockAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/HideInBlockAnimator.java index a3fb2b01..e271eef8 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/HideInBlockAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/HideInBlockAnimator.java @@ -1,6 +1,7 @@ package com.alrex.parcool.client.animation.impl; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -10,7 +11,6 @@ import com.alrex.parcool.utilities.MathUtil; import com.alrex.parcool.utilities.VectorUtil; import net.minecraft.util.math.MathHelper; -import net.minecraft.util.math.vector.Vector3d; public class HideInBlockAnimator extends Animator { public static HideInBlockAnimator crouch() { @@ -60,7 +60,7 @@ public boolean rotatePre(PlayerWrapper player, Parkourability parkourability, Pl float phase = (getTick() + rotator.getPartialTick()) / 5f; if (phase > 1f) phase = 1f; float factor = Easing.with(phase).sinInOut(0f, 1f, 0, 1f).get(); - Vector3d lookVec = parkourability.get(HideInBlock.class).getLookDirection(); + Vec3Wrapper lookVec = parkourability.get(HideInBlock.class).getLookDirection(); if (lookVec == null) return false; if (standing) { float playerYRot = player.getRotatedYRot(rotator); diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/RideZiplineAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/RideZiplineAnimator.java index 3eba12fb..eb971501 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/RideZiplineAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/RideZiplineAnimator.java @@ -1,6 +1,8 @@ package com.alrex.parcool.client.animation.impl; +import com.alrex.parcool.api.compatibility.AxisWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -8,8 +10,6 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.VectorUtil; import net.minecraft.util.math.MathHelper; -import net.minecraft.util.math.vector.Vector3d; -import net.minecraft.util.math.vector.Vector3f; import net.minecraftforge.event.TickEvent; public class RideZiplineAnimator extends Animator { @@ -41,9 +41,9 @@ public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability @Override public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { - Vector3d offset = parkourability.get(RideZipline.class).getEndOffsetFromStart(); + Vec3Wrapper offset = parkourability.get(RideZipline.class).getEndOffsetFromStart(); if (offset == null) return; - double angleDifference = VectorUtil.toYawRadian(player.getLookAngle()) - VectorUtil.toYawRadian(new Vector3d(offset.x(), 0, offset.z())); + double angleDifference = VectorUtil.toYawRadian(player.getLookAngle()) - VectorUtil.toYawRadian(new Vec3Wrapper(offset.x(), 0, offset.z())); double angleCos = Math.cos(angleDifference); double angleSin = Math.sin(angleDifference); double angleCosAbs = Math.abs(angleCos); @@ -65,14 +65,14 @@ public void onRenderTick(TickEvent.RenderTickEvent event, PlayerWrapper player, @Override public void rotatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { - Vector3d offset = parkourability.get(RideZipline.class).getEndOffsetFromStart(); + Vec3Wrapper offset = parkourability.get(RideZipline.class).getEndOffsetFromStart(); if (offset == null) return; - Vector3d rotationAxis = new Vector3d(0, 0, 1) - .yRot((float) (Math.PI / 2 + VectorUtil.toYawRadian(player.getLookAngle()) - VectorUtil.toYawRadian(new Vector3d(offset.x(), 0, offset.z())))) + Vec3Wrapper rotationAxis = new Vec3Wrapper(0, 0, 1) + .yRot((float) (Math.PI / 2 + VectorUtil.toYawRadian(player.getLookAngle()) - VectorUtil.toYawRadian(new Vec3Wrapper(offset.x(), 0, offset.z())))) .normalize(); double angle = MathHelper.lerp(rotator.getPartialTick(), oldAngleRadian, currentAngleRadian); rotator.startBasedTop() - .rotate((float) angle, new Vector3f((float) rotationAxis.x(), 0f, (float) rotationAxis.z())) + .rotate((float) angle, AxisWrapper.createXZ(rotationAxis)) .end(); } } diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/SlidingAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/SlidingAnimator.java index 71cf43dc..a9a25699 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/SlidingAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/SlidingAnimator.java @@ -1,6 +1,7 @@ package com.alrex.parcool.client.animation.impl; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -8,7 +9,6 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.Easing; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.util.math.vector.Vector3d; public class SlidingAnimator extends Animator { private static final int MAX_TRANSITION_TICK = 5; @@ -51,7 +51,7 @@ public void animatePost(PlayerWrapper player, Parkourability parkourability, Pla @Override public boolean rotatePre(PlayerWrapper player, Parkourability parkourability, PlayerModelRotator rotator) { - Vector3d vec = parkourability.get(Slide.class).getSlidingVector(); + Vec3Wrapper vec = parkourability.get(Slide.class).getSlidingVector(); if (vec == null) return false; float animFactor = (getTick() + rotator.getPartialTick()) / MAX_TRANSITION_TICK; float yRot = (float) VectorUtil.toYawDegree(vec); diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/WallSlideAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/WallSlideAnimator.java index f6c192f0..5a046a3e 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/WallSlideAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/WallSlideAnimator.java @@ -1,12 +1,12 @@ package com.alrex.parcool.client.animation.impl; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.WallSlide; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.util.math.vector.Vector3d; public class WallSlideAnimator extends Animator { @Override @@ -16,13 +16,13 @@ public boolean shouldRemoved(PlayerWrapper player, Parkourability parkourability @Override public void animatePost(PlayerWrapper player, Parkourability parkourability, PlayerModelTransformer transformer) { - Vector3d wall = parkourability.get(WallSlide.class).getLeanedWallDirection(); + Vec3Wrapper wall = parkourability.get(WallSlide.class).getLeanedWallDirection(); if (wall == null) return; - Vector3d bodyVec = player.getVectorYBodyRot(); - Vector3d vec = new Vector3d(bodyVec.x(), 0, bodyVec.z()).normalize(); + Vec3Wrapper bodyVec = player.getVectorYBodyRot(); + Vec3Wrapper vec = new Vec3Wrapper(bodyVec.x(), 0, bodyVec.z()).normalize(); - Vector3d dividedVec = - new Vector3d( + Vec3Wrapper dividedVec = + new Vec3Wrapper( vec.x() * wall.x() + vec.z() * wall.z(), 0, -vec.x() * wall.z() + vec.z() * wall.x() ).normalize(); diff --git a/src/main/java/com/alrex/parcool/client/renderer/entity/ZiplineRopeRenderer.java b/src/main/java/com/alrex/parcool/client/renderer/entity/ZiplineRopeRenderer.java index c2c3c2b2..09ec45ac 100644 --- a/src/main/java/com/alrex/parcool/client/renderer/entity/ZiplineRopeRenderer.java +++ b/src/main/java/com/alrex/parcool/client/renderer/entity/ZiplineRopeRenderer.java @@ -1,5 +1,8 @@ package com.alrex.parcool.client.renderer.entity; +import com.alrex.parcool.api.compatibility.AxisWrapper; +import com.alrex.parcool.api.compatibility.EntityWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.renderer.RenderTypes; import com.alrex.parcool.common.entity.zipline.ZiplineRopeEntity; import com.alrex.parcool.common.zipline.Zipline; @@ -16,8 +19,6 @@ import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.MathHelper; import net.minecraft.util.math.vector.Matrix4f; -import net.minecraft.util.math.vector.Vector3d; -import net.minecraft.util.math.vector.Vector3f; import net.minecraft.world.LightType; import javax.annotation.Nonnull; @@ -50,17 +51,18 @@ private void renderRope(ZiplineRopeEntity entity, float partialTick, MatrixStack BlockPos start = entity.getStartPos(); BlockPos end = entity.getEndPos(); if (start == BlockPos.ZERO && end == BlockPos.ZERO) return; + EntityWrapper entityWrapper = EntityWrapper.get(entity); int color = entity.getColor(); float r = ((0xFF0000 & color) >> 16) / 255f; float g = ((0x00FF00 & color) >> 8) / 255f; float b = (0x0000FF & color) / 255f; - Vector3d entityPos = entity.position(); + Vec3Wrapper entityPos = entityWrapper.position(); Zipline zipline = entity.getZipline(); - Vector3d startPos = zipline.getStartPos(); - Vector3d startPosOffset = startPos.subtract(entityPos); - Vector3d endOffsetFromStart = zipline.getOffsetToEndFromStart(); + Vec3Wrapper startPos = zipline.getStartPos(); + Vec3Wrapper startPosOffset = startPos.subtract(entityPos); + Vec3Wrapper endOffsetFromStart = zipline.getOffsetToEndFromStart(); boolean render3d = ParCoolConfig.Client.Booleans.Enable3DRenderingForZipline.get(); @@ -131,8 +133,8 @@ private void renderRopeSingleBlock2D( float phase = (float) (currentCount + i) / maxCount; int lightLevel = LightTexture.pack((int) MathHelper.lerp(phase, startBlockLightLevel, endBlockLightLevel), (int) MathHelper.lerp(phase, startSkyBrightness, endSkyBrightness)); - Vector3d midPointD = zipline.getMidPointOffsetFromStart(phase); - Vector3f midPoint = new Vector3f((float) midPointD.x(), (float) midPointD.y(), (float) midPointD.z()); + Vec3Wrapper midPointD = zipline.getMidPointOffsetFromStart(phase); + AxisWrapper midPoint = AxisWrapper.fromVector(midPointD); final float width = 0.075f; float tilt = zipline.getSlope(phase); @@ -197,14 +199,14 @@ private void renderRopeSingleBlock3D( int startSkyBrightness, int endSkyBrightness, float r, float g, float b ) { - Vector3f[] vertexList = new Vector3f[8]; + AxisWrapper[] vertexList = new AxisWrapper[8]; int[] lightLevelList = new int[2]; for (int i = 0; i < 2; i++) { float phase = (float) (currentCount + i) / maxCount; lightLevelList[i] = LightTexture.pack((int) MathHelper.lerp(phase, startBlockLightLevel, endBlockLightLevel), (int) MathHelper.lerp(phase, startSkyBrightness, endSkyBrightness)); - Vector3d midPointD = zipline.getMidPointOffsetFromStart(phase); - Vector3f midPoint = new Vector3f((float) midPointD.x(), (float) midPointD.y(), (float) midPointD.z()); + Vec3Wrapper midPointD = zipline.getMidPointOffsetFromStart(phase); + AxisWrapper midPoint = AxisWrapper.fromVector(midPointD); final float width = 0.075f; float tilt = zipline.getSlope(phase); @@ -214,22 +216,22 @@ private void renderRopeSingleBlock3D( float zBaseOffset = unitLengthZ * width * tilt * tiltInv / 1.41421356f; float xOffset = unitLengthZ * width / 1.41421356f; float zOffset = -unitLengthX * width / 1.41421356f; - vertexList[4 * i] = new Vector3f( + vertexList[4 * i] = new AxisWrapper( (midPoint.x() - xBaseOffset + xOffset), (midPoint.y() + yOffset), (midPoint.z() - zBaseOffset + zOffset) ); - vertexList[4 * i + 1] = new Vector3f( + vertexList[4 * i + 1] = new AxisWrapper( (midPoint.x() - xBaseOffset - xOffset), (midPoint.y() + yOffset), (midPoint.z() - zBaseOffset - zOffset) ); - vertexList[4 * i + 2] = new Vector3f( + vertexList[4 * i + 2] = new AxisWrapper( (midPoint.x() + xBaseOffset - xOffset), (midPoint.y() - yOffset), (midPoint.z() + zBaseOffset - zOffset) ); - vertexList[4 * i + 3] = new Vector3f( + vertexList[4 * i + 3] = new AxisWrapper( (midPoint.x() + xBaseOffset + xOffset), (midPoint.y() - yOffset), (midPoint.z() + zBaseOffset + zOffset) diff --git a/src/main/java/com/alrex/parcool/common/action/BehaviorEnforcer.java b/src/main/java/com/alrex/parcool/common/action/BehaviorEnforcer.java index 07f07804..26e41b40 100644 --- a/src/main/java/com/alrex/parcool/common/action/BehaviorEnforcer.java +++ b/src/main/java/com/alrex/parcool/common/action/BehaviorEnforcer.java @@ -1,11 +1,13 @@ package com.alrex.parcool.common.action; import net.minecraft.client.settings.PointOfView; -import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import javax.annotation.Nullable; + +import com.alrex.parcool.api.compatibility.Vec3Wrapper; + import java.util.TreeMap; import java.util.function.Supplier; @@ -62,9 +64,9 @@ T getBehavior() { private final TreeMap fallFlyingCancelMarks = new TreeMap<>(); private final TreeMap showNameCancelMarks = new TreeMap<>(); @Nullable - private Enforcer movementEnforcer = null; + private Enforcer movementEnforcer = null; @Nullable - private Enforcer positionEnforcer = null; + private Enforcer positionEnforcer = null; public void addMarkerCancellingJump(ID id, Marker marker) { jumpCancelMarks.put(id, marker); @@ -90,11 +92,11 @@ public void addMarkerCancellingShowName(ID id, Marker marker) { showNameCancelMarks.put(id, marker); } - public void setMarkerEnforceMovePoint(Marker marker, Supplier movementSupplier) { + public void setMarkerEnforceMovePoint(Marker marker, Supplier movementSupplier) { movementEnforcer = new Enforcer<>(marker, movementSupplier); } - public void setMarkerEnforcePosition(Marker marker, Supplier movementSupplier) { + public void setMarkerEnforcePosition(Marker marker, Supplier movementSupplier) { positionEnforcer = new Enforcer<>(marker, movementSupplier); } @@ -129,7 +131,7 @@ public boolean cancelShowingName() { } @Nullable - public Vector3d getEnforcedMovePoint() { + public Vec3Wrapper getEnforcedMovePoint() { if (movementEnforcer != null && movementEnforcer.remain()) { return movementEnforcer.getBehavior(); } @@ -138,7 +140,7 @@ public Vector3d getEnforcedMovePoint() { } @Nullable - public Vector3d getEnforcedPosition() { + public Vec3Wrapper getEnforcedPosition() { if (positionEnforcer != null && positionEnforcer.remain()) { return positionEnforcer.getBehavior(); } diff --git a/src/main/java/com/alrex/parcool/common/action/impl/BreakfallReady.java b/src/main/java/com/alrex/parcool/common/action/impl/BreakfallReady.java index 61d2da45..b0d8e966 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/BreakfallReady.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/BreakfallReady.java @@ -2,6 +2,7 @@ import com.alrex.parcool.api.SoundEvents; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.StaminaConsumeTiming; @@ -9,7 +10,6 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.particles.ParticleTypes; -import net.minecraft.util.math.vector.Vector3d; import java.nio.ByteBuffer; import java.util.Random; @@ -23,7 +23,7 @@ public void startBreakfall(PlayerWrapper player, Parkourability parkourability, if (ParCoolConfig.Client.Booleans.EnableActionParticles.get() && ParCoolConfig.Client.Booleans.EnableActionParticlesOfJustTimeBreakfall.get() ) { - Vector3d pos = player.position(); + Vec3Wrapper pos = player.position(); Random rand = player.getRandom(); for (int i = 0; i < 12; i++) { player.addParticle(ParticleTypes.END_ROD, diff --git a/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java b/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java index 08ee0629..b2c83a6c 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java @@ -3,6 +3,7 @@ import com.alrex.parcool.api.SoundEvents; import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.CatLeapAnimator; import com.alrex.parcool.client.input.KeyRecorder; import com.alrex.parcool.common.action.Action; @@ -16,7 +17,6 @@ import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -55,7 +55,7 @@ public void onClientTick(PlayerWrapper player, Parkourability parkourability, IS @OnlyIn(Dist.CLIENT) @Override public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { - Vector3d movement = player.getDeltaMovement(); + Vec3Wrapper movement = player.getDeltaMovement(); if (movement.lengthSqr() < 0.001) return false; movement = movement.multiply(1, 0, 1).normalize(); startInfo.putDouble(movement.x()).putDouble(movement.z()); @@ -83,13 +83,13 @@ public boolean canContinue(PlayerWrapper player, Parkourability parkourability, @Override public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { - Vector3d jumpDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); + Vec3Wrapper jumpDirection = new Vec3Wrapper(startData.getDouble(), 0, startData.getDouble()); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.CATLEAP.get(), 1, 1); coolTimeTick = MAX_COOL_TIME_TICK; spawnJumpEffect(player, jumpDirection); player.jumpFromGround(); - Vector3d motionVec = player.getDeltaMovement(); + Vec3Wrapper motionVec = player.getDeltaMovement(); player.setDeltaMovement(jumpDirection.x(), motionVec.y() * 1.16667, jumpDirection.z()); Animation animation = Animation.get(player); if (animation != null) animation.setAnimator(new CatLeapAnimator()); @@ -97,7 +97,7 @@ public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourabi @Override public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { - Vector3d jumpDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); + Vec3Wrapper jumpDirection = new Vec3Wrapper(startData.getDouble(), 0, startData.getDouble()); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.CATLEAP.get(), 1, 1); spawnJumpEffect(player, jumpDirection); @@ -121,22 +121,22 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { } @OnlyIn(Dist.CLIENT) - private void spawnJumpEffect(PlayerWrapper player, Vector3d jumpDirection) { + private void spawnJumpEffect(PlayerWrapper player, Vec3Wrapper jumpDirection) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; World level = player.getLevel(); - Vector3d pos = player.position(); + Vec3Wrapper pos = player.position(); BlockPos blockpos = new BlockPos(pos.add(0, -0.2, 0)); if (!level.isLoaded(blockpos)) return; float width = player.getBbWidth(); BlockState blockstate = level.getBlockState(blockpos); if (blockstate.getRenderShape() != BlockRenderType.INVISIBLE) { for (int i = 0; i < 20; i++) { - Vector3d particlePos = new Vector3d( + Vec3Wrapper particlePos = new Vec3Wrapper( pos.x() + (jumpDirection.x() * -0.5 + player.getRandom().nextDouble() - 0.5D) * width, pos.y() + 0.1D, pos.z() + (jumpDirection.z() * -0.5 + player.getRandom().nextDouble() - 0.5D) * width ); - Vector3d particleSpeed = particlePos.subtract(pos).normalize().scale(2.5 + 8 * player.getRandom().nextDouble()).add(0, 1.5, 0); + Vec3Wrapper particleSpeed = particlePos.subtract(pos).normalize().scale(2.5 + 8 * player.getRandom().nextDouble()).add(0, 1.5, 0); level.addParticle( new BlockParticleData(ParticleTypes.BLOCK, blockstate).setPos(blockpos), particlePos.x(), diff --git a/src/main/java/com/alrex/parcool/common/action/impl/ChargeJump.java b/src/main/java/com/alrex/parcool/common/action/impl/ChargeJump.java index ecb90e69..d5821ce6 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/ChargeJump.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/ChargeJump.java @@ -4,6 +4,7 @@ import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.api.compatibility.EventBusWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.ChargeJumpAnimator; import com.alrex.parcool.client.animation.impl.JumpChargingAnimator; import com.alrex.parcool.client.input.KeyRecorder; @@ -14,7 +15,6 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.util.math.vector.Vector3d; import java.nio.ByteBuffer; public class ChargeJump extends Action { @@ -90,8 +90,8 @@ public void onClientTick(PlayerWrapper player, Parkourability parkourability, IS notChargeTick++; } if (isCharging()) { - Vector3d targetAngle = VectorUtil.fromYawDegree(player.getYHeadRot()); - Vector3d currentAngle = VectorUtil.fromYawDegree(player.getYBodyRot()); + Vec3Wrapper targetAngle = VectorUtil.fromYawDegree(player.getYHeadRot()); + Vec3Wrapper currentAngle = VectorUtil.fromYawDegree(player.getYBodyRot()); double differenceAngle = Math.atan( (currentAngle.x() * targetAngle.z() - targetAngle.x() * currentAngle.z()) / (targetAngle.x() * currentAngle.x() + targetAngle.z() * currentAngle.z()) diff --git a/src/main/java/com/alrex/parcool/common/action/impl/ClimbUp.java b/src/main/java/com/alrex/parcool/common/action/impl/ClimbUp.java index a7330fc7..dc397940 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/ClimbUp.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/ClimbUp.java @@ -2,6 +2,7 @@ import com.alrex.parcool.api.SoundEvents; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.ClimbUpAnimator; import com.alrex.parcool.client.input.KeyRecorder; import com.alrex.parcool.common.action.Action; @@ -10,7 +11,6 @@ import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.config.ParCoolConfig; -import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -36,7 +36,7 @@ public boolean canContinue(PlayerWrapper player, Parkourability parkourability, @OnlyIn(Dist.CLIENT) @Override public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { - Vector3d speed = player.getDeltaMovement(); + Vec3Wrapper speed = player.getDeltaMovement(); player.setDeltaMovement(speed.x(), 0.6, speed.z()); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.CLING_TO_CLIFF_JUMP.get(), 1f, 1f); diff --git a/src/main/java/com/alrex/parcool/common/action/impl/ClingToCliff.java b/src/main/java/com/alrex/parcool/common/action/impl/ClingToCliff.java index 4acf7b00..fc22cbe8 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/ClingToCliff.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/ClingToCliff.java @@ -2,6 +2,7 @@ import com.alrex.parcool.api.SoundEvents; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.ClingToCliffAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -14,7 +15,6 @@ import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.VectorUtil; import com.alrex.parcool.utilities.WorldUtil; -import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.event.TickEvent; @@ -32,7 +32,7 @@ public enum ControlType { private float armSwingAmount = 0; private FacingDirection facingDirection = FacingDirection.ToWall; @Nullable - private Vector3d clingWallDirection = null; + private Vec3Wrapper clingWallDirection = null; public float getArmSwingAmount() { return armSwingAmount; @@ -57,7 +57,7 @@ public boolean canStart(PlayerWrapper player, Parkourability parkourability, ISt && (KeyBindings.getKeyGrabWall().getKey().equals(KeyBindings.getKeySneak().getKey()) || !player.isShiftKeyDown()) ); if (!value) return false; - Vector3d wallVec = WorldUtil.getGrabbableWall(player); + Vec3Wrapper wallVec = WorldUtil.getGrabbableWall(player); if (wallVec == null) return false; startInfo.putDouble(wallVec.x()) .putDouble(wallVec.z()); @@ -93,7 +93,7 @@ public void onStart(PlayerWrapper player, Parkourability parkourability, ByteBuf @OnlyIn(Dist.CLIENT) @Override public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { - clingWallDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); + clingWallDirection = new Vec3Wrapper(startData.getDouble(), 0, startData.getDouble()); facingDirection = FacingDirection.ToWall; armSwingAmount = 0; if (!KeyBindings.getKeyGrabWall().getKey().equals(KeyBindings.getKeySneak().getKey())) { @@ -107,7 +107,7 @@ public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourabi @Override public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { - clingWallDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); + clingWallDirection = new Vec3Wrapper(startData.getDouble(), 0, startData.getDouble()); facingDirection = FacingDirection.ToWall; armSwingAmount = 0; if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) @@ -124,7 +124,7 @@ public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability park player.setDeltaMovement(0, 0, 0); } else { if (clingWallDirection != null && facingDirection == FacingDirection.ToWall) { - Vector3d vec = clingWallDirection.yRot((float) (Math.PI / 2)).normalize().scale(0.1); + Vec3Wrapper vec = clingWallDirection.yRot((float) (Math.PI / 2)).normalize().scale(0.1); if (KeyBindings.isKeyLeftDown()) player.setDeltaMovement(vec); else if (KeyBindings.isKeyRightDown()) player.setDeltaMovement(vec.reverse()); else player.setDeltaMovement(0, 0, 0); @@ -139,9 +139,9 @@ public void onWorkingTickInClient(PlayerWrapper player, Parkourability parkourab clingWallDirection = WorldUtil.getGrabbableWall(player); if (clingWallDirection == null) return; clingWallDirection = clingWallDirection.normalize(); - Vector3d lookingAngle = player.getLookAngle().multiply(1, 0, 1).normalize(); - Vector3d angle = - new Vector3d( + Vec3Wrapper lookingAngle = player.getLookAngle().multiply(1, 0, 1).normalize(); + Vec3Wrapper angle = + new Vec3Wrapper( clingWallDirection.x() * lookingAngle.x() + clingWallDirection.z() * lookingAngle.z(), 0, -clingWallDirection.x() * lookingAngle.z() + clingWallDirection.z() * lookingAngle.x() ).normalize(); diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Dodge.java b/src/main/java/com/alrex/parcool/common/action/impl/Dodge.java index b42130ce..0a029803 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Dodge.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Dodge.java @@ -3,6 +3,7 @@ import com.alrex.parcool.api.SoundEvents; import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.DodgeAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -16,7 +17,6 @@ import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.extern.AdditionalMods; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -180,8 +180,8 @@ public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourabi successivelyCoolTick = getSuccessiveCoolTime(parkourability.getActionInfo()); if (!player.isOnGround()) return; - Vector3d lookVec = VectorUtil.fromYawDegree(player.getYHeadRot()); - Vector3d dodgeVec = Vector3d.ZERO; + Vec3Wrapper lookVec = VectorUtil.fromYawDegree(player.getYHeadRot()); + Vec3Wrapper dodgeVec = Vec3Wrapper.ZERO; switch (dodgeDirection) { case Front: dodgeVec = lookVec; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/HangDown.java b/src/main/java/com/alrex/parcool/common/action/impl/HangDown.java index 701445d4..e330690a 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/HangDown.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/HangDown.java @@ -2,6 +2,7 @@ import com.alrex.parcool.api.SoundEvents; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.HangAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; @@ -13,7 +14,6 @@ import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.VectorUtil; import com.alrex.parcool.utilities.WorldUtil; -import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.event.TickEvent; @@ -80,7 +80,7 @@ private void setup(PlayerWrapper player, ByteBuffer startData) { armSwingAmount = 0; bodySwingAngleFactor = startData.getDouble(); hangingBarAxis = WorldUtil.getHangableBars(player); - Vector3d bodyVec = VectorUtil.fromYawDegree(player.getYBodyRot()); + Vec3Wrapper bodyVec = VectorUtil.fromYawDegree(player.getYBodyRot()); orthogonalToBar = (hangingBarAxis == BarAxis.X && Math.abs(bodyVec.x()) < Math.abs(bodyVec.z())) || (hangingBarAxis == BarAxis.Z && Math.abs(bodyVec.z()) < Math.abs(bodyVec.x())); player.setDeltaMovement(0, 0, 0); @@ -111,7 +111,7 @@ public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourabi @OnlyIn(Dist.CLIENT) @Override public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { - Vector3d bodyVec = VectorUtil.fromYawDegree(player.getYBodyRot()); + Vec3Wrapper bodyVec = VectorUtil.fromYawDegree(player.getYBodyRot()); final double speed = 0.1; double xSpeed = 0, zSpeed = 0; if (orthogonalToBar) { @@ -139,7 +139,7 @@ public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability park @Override public void onWorkingTickInClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { hangingBarAxis = WorldUtil.getHangableBars(player); - Vector3d bodyVec = VectorUtil.fromYawDegree(player.getYBodyRot()); + Vec3Wrapper bodyVec = VectorUtil.fromYawDegree(player.getYBodyRot()); orthogonalToBar = (hangingBarAxis == BarAxis.X && Math.abs(bodyVec.x()) < Math.abs(bodyVec.z())) || (hangingBarAxis == BarAxis.Z && Math.abs(bodyVec.z()) < Math.abs(bodyVec.x())); @@ -165,13 +165,13 @@ public void restoreSynchronizedState(ByteBuffer buffer) { public void onRenderTick(TickEvent.RenderTickEvent event, PlayerWrapper player, Parkourability parkourability) { if (isDoing()) { if (hangingBarAxis == null) return; - Vector3d bodyVec = VectorUtil.fromYawDegree(player.getYBodyRot()).normalize(); - Vector3d lookVec = player.getLookAngle(); - Vector3d idealLookVec; + Vec3Wrapper bodyVec = VectorUtil.fromYawDegree(player.getYBodyRot()).normalize(); + Vec3Wrapper lookVec = player.getLookAngle(); + Vec3Wrapper idealLookVec; if (Math.abs(lookVec.x()) > Math.abs(lookVec.z())) { - idealLookVec = new Vector3d(lookVec.x() > 0 ? 1 : -1, 0, 0); + idealLookVec = new Vec3Wrapper(lookVec.x() > 0 ? 1 : -1, 0, 0); } else { - idealLookVec = new Vector3d(0, 0, lookVec.z() > 0 ? 1 : -1); + idealLookVec = new Vec3Wrapper(0, 0, lookVec.z() > 0 ? 1 : -1); } double differenceAngle = Math.acos(bodyVec.dot(idealLookVec)); differenceAngle /= 4; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java b/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java index 1efb06e9..706ac38b 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.RenderBehaviorEnforcer; import com.alrex.parcool.client.animation.impl.HideInBlockAnimator; import com.alrex.parcool.client.input.KeyBindings; @@ -19,7 +20,6 @@ import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.BlockRayTraceResult; import net.minecraft.util.math.RayTraceResult; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -31,17 +31,17 @@ public class HideInBlock extends Action { private static final BehaviorEnforcer.ID ID_SHOW_NAME = BehaviorEnforcer.newID(); private static final BehaviorEnforcer.ID ID_SNEAK = BehaviorEnforcer.newID(); @Nullable - Vector3d hidingPoint = null; + Vec3Wrapper hidingPoint = null; @Nullable Tuple hidingArea = null; @Nullable - Vector3d enterPoint = null; + Vec3Wrapper enterPoint = null; @Nullable - Vector3d lookDirection = null; + Vec3Wrapper lookDirection = null; boolean hidingBlockChanged = false; @Nullable - public Vector3d getLookDirection() { + public Vec3Wrapper getLookDirection() { return lookDirection; } @@ -66,7 +66,7 @@ public boolean canStart(PlayerWrapper player, Parkourability parkourability, ISt BlockPos lookingBlock = ((BlockRayTraceResult) result).getBlockPos(); Tuple hideArea = WorldUtil.getHideAbleSpace(player, lookingBlock); if (hideArea == null) return false; - Vector3d hidePoint = new Vector3d( + Vec3Wrapper hidePoint = new Vec3Wrapper( 0.5 + (hideArea.getA().getX() + hideArea.getB().getX()) / 2., Math.min(hideArea.getA().getY(), hideArea.getB().getY()), 0.5 + (hideArea.getA().getZ() + hideArea.getB().getZ()) / 2. @@ -81,18 +81,18 @@ public boolean canStart(PlayerWrapper player, Parkourability parkourability, ISt int maxZ = Math.max(hideArea.getA().getZ(), hideArea.getB().getZ()); hideArea = new Tuple<>(new BlockPos(minX, minY, minZ), new BlockPos(maxX, maxY, maxZ)); } - Vector3d direction; + Vec3Wrapper direction; boolean stand = player.getBbHeight() < (hideArea.getB().getY() - hideArea.getA().getY() + 1); if (stand) { - Vector3d lookAngle = player.getLookAngle(); + Vec3Wrapper lookAngle = player.getLookAngle(); direction = Math.abs(lookAngle.x()) > Math.abs(lookAngle.z()) ? - new Vector3d(lookAngle.x() > 0 ? 1 : -1, 0, 0) : - new Vector3d(0, 0, lookAngle.z() > 0 ? 1 : -1); + new Vec3Wrapper(lookAngle.x() > 0 ? 1 : -1, 0, 0) : + new Vec3Wrapper(0, 0, lookAngle.z() > 0 ? 1 : -1); } else { boolean zLonger = Math.abs(hideArea.getA().getZ() - hideArea.getB().getZ()) > Math.abs(hideArea.getA().getX() - hideArea.getB().getX()); direction = zLonger ? - new Vector3d(0, 0, player.getLookAngle().z() > 0 ? 1 : -1) : - new Vector3d(player.getLookAngle().x() > 0 ? 1 : -1, 0, 0); + new Vec3Wrapper(0, 0, player.getLookAngle().z() > 0 ? 1 : -1) : + new Vec3Wrapper(player.getLookAngle().x() > 0 ? 1 : -1, 0, 0); } BufferUtil.wrap(startInfo) .putBoolean(stand) @@ -167,7 +167,7 @@ public void onWorkingTickInServer(PlayerWrapper player, Parkourability parkourab @Override public void onWorkingTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { - player.setDeltaMovement(Vector3d.ZERO); + player.setDeltaMovement(Vec3Wrapper.ZERO); player.disablePhysics(); player.setSprinting(false); player.setStandingPose(); @@ -175,8 +175,8 @@ public void onWorkingTick(PlayerWrapper player, Parkourability parkourability, I @Override public void onStopInLocalClient(PlayerWrapper player) { - final Vector3d hidePos = hidingPoint; - final Vector3d entPos = enterPoint; + final Vec3Wrapper hidePos = hidingPoint; + final Vec3Wrapper entPos = enterPoint; Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; parkourability.getBehaviorEnforcer().setMarkerEnforcePosition( diff --git a/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java b/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java index 4d543755..74ffb924 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java @@ -2,6 +2,7 @@ import com.alrex.parcool.api.SoundEvents; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.HorizontalWallRunAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; @@ -21,7 +22,6 @@ import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -43,8 +43,8 @@ private int getMaxRunningTick(ActionInfo info) { } private boolean wallIsRightward = false; - private Vector3d runningWallDirection = null; - private Vector3d runningDirection = null; + private Vec3Wrapper runningWallDirection = null; + private Vec3Wrapper runningDirection = null; @Override public void onClientTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { @@ -54,19 +54,19 @@ public void onClientTick(PlayerWrapper player, Parkourability parkourability, IS @OnlyIn(Dist.CLIENT) @Override public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { - Vector3d wallDirection = WorldUtil.getRunnableWall(player, player.getBbWidth() * 0.65f); + Vec3Wrapper wallDirection = WorldUtil.getRunnableWall(player, player.getBbWidth() * 0.65f); if (wallDirection == null) return; if (runningWallDirection == null) return; if (runningDirection == null) return; - Vector3d lookVec = VectorUtil.fromYawDegree(player.getYBodyRot()); + Vec3Wrapper lookVec = VectorUtil.fromYawDegree(player.getYBodyRot()); double differenceAngle = Math.asin( - new Vector3d( + new Vec3Wrapper( lookVec.x() * runningDirection.x() + lookVec.z() * runningDirection.z(), 0, -lookVec.x() * runningDirection.z() + lookVec.z() * runningDirection.x() ).normalize().z() ); bodyYaw = (float) VectorUtil.toYawDegree(lookVec.yRot((float) (differenceAngle / 10))); - Vector3d movement = player.getDeltaMovement(); + Vec3Wrapper movement = player.getDeltaMovement(); BlockPos leanedBlock = new BlockPos( player.getX() + runningWallDirection.x(), player.getBoundingBox().minY + player.getBbHeight() * 0.5, @@ -91,14 +91,14 @@ public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability park @OnlyIn(Dist.CLIENT) @Override public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { - Vector3d wallDirection = WorldUtil.getRunnableWall(player, player.getBbWidth() * 0.65f); + Vec3Wrapper wallDirection = WorldUtil.getRunnableWall(player, player.getBbWidth() * 0.65f); if (wallDirection == null) return false; - Vector3d wallVec = wallDirection.normalize(); - Vector3d lookDirection = VectorUtil.fromYawDegree(player.getYBodyRot()); - lookDirection = new Vector3d(lookDirection.x(), 0, lookDirection.z()).normalize(); + Vec3Wrapper wallVec = wallDirection.normalize(); + Vec3Wrapper lookDirection = VectorUtil.fromYawDegree(player.getYBodyRot()); + lookDirection = new Vec3Wrapper(lookDirection.x(), 0, lookDirection.z()).normalize(); //doing "wallDirection/direction" as complex number(x + z i) to calculate difference of player's direction to steps - Vector3d dividedVec = - new Vector3d( + Vec3Wrapper dividedVec = + new Vec3Wrapper( wallVec.x() * lookDirection.x() + wallVec.z() * lookDirection.z(), 0, -wallVec.x() * lookDirection.z() + wallVec.z() * lookDirection.x() ).normalize(); @@ -106,7 +106,7 @@ public boolean canStart(PlayerWrapper player, Parkourability parkourability, ISt return false; } BufferUtil.wrap(startInfo).putBoolean(dividedVec.z() > 0/*if true, wall is in right side*/); - Vector3d runDirection = wallVec.yRot((float) (Math.PI / 2)); + Vec3Wrapper runDirection = wallVec.yRot((float) (Math.PI / 2)); if (runDirection.dot(lookDirection) < 0) { runDirection = runDirection.reverse(); } @@ -140,7 +140,7 @@ public boolean canStart(PlayerWrapper player, Parkourability parkourability, ISt @OnlyIn(Dist.CLIENT) @Override public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { - Vector3d wallDirection = WorldUtil.getRunnableWall(player, player.getBbWidth() * 0.65f); + Vec3Wrapper wallDirection = WorldUtil.getRunnableWall(player, player.getBbWidth() * 0.65f); if (wallDirection == null) return false; return (getDoingTick() < getMaxRunningTick(parkourability.getActionInfo()) && !stamina.isExhausted() @@ -164,8 +164,8 @@ public void onStop(PlayerWrapper player) { @Override public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { wallIsRightward = BufferUtil.getBoolean(startData); - runningWallDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); - runningDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); + runningWallDirection = new Vec3Wrapper(startData.getDouble(), 0, startData.getDouble()); + runningDirection = new Vec3Wrapper(startData.getDouble(), 0, startData.getDouble()); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.HORIZONTAL_WALL_RUN.get(), 1f, 1f); Animation animation = Animation.get(player); @@ -177,8 +177,8 @@ public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourabi @Override public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { wallIsRightward = BufferUtil.getBoolean(startData); - runningWallDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); - runningDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); + runningWallDirection = new Vec3Wrapper(startData.getDouble(), 0, startData.getDouble()); + runningDirection = new Vec3Wrapper(startData.getDouble(), 0, startData.getDouble()); Animation animation = Animation.get(player); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.HORIZONTAL_WALL_RUN.get(), 1f, 1f); @@ -192,9 +192,9 @@ public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourabi public void onRenderTick(TickEvent.RenderTickEvent event, PlayerWrapper player, Parkourability parkourability) { if (isDoing()) { if (runningDirection == null) return; - Vector3d lookVec = VectorUtil.fromYawDegree(player.getYHeadRot()); + Vec3Wrapper lookVec = VectorUtil.fromYawDegree(player.getYHeadRot()); double differenceAngle = Math.asin( - new Vector3d( + new Vec3Wrapper( lookVec.x() * runningDirection.x() + lookVec.z() * runningDirection.z(), 0, -lookVec.x() * runningDirection.z() + lookVec.z() * runningDirection.x() ).normalize().z() @@ -233,7 +233,7 @@ public void spawnRunningParticle(PlayerWrapper player) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; if (runningDirection == null || runningWallDirection == null) return; World level = player.getLevel(); - Vector3d pos = player.position(); + Vec3Wrapper pos = player.position(); BlockPos leanedBlock = new BlockPos( pos.add(runningWallDirection.x(), player.getBbHeight() * 0.25, runningWallDirection.z()) ); @@ -241,16 +241,16 @@ public void spawnRunningParticle(PlayerWrapper player) { float width = player.getBbWidth(); BlockState blockstate = level.getBlockState(leanedBlock); - Vector3d wallDirection = runningWallDirection.normalize(); - Vector3d orthogonalToWallVec = wallDirection.yRot((float) (Math.PI / 2)); - Vector3d particleBaseDirection = runningDirection.subtract(wallDirection); + Vec3Wrapper wallDirection = runningWallDirection.normalize(); + Vec3Wrapper orthogonalToWallVec = wallDirection.yRot((float) (Math.PI / 2)); + Vec3Wrapper particleBaseDirection = runningDirection.subtract(wallDirection); if (blockstate.getRenderShape() != BlockRenderType.INVISIBLE) { - Vector3d particlePos = new Vector3d( + Vec3Wrapper particlePos = new Vec3Wrapper( pos.x() + (wallDirection.x() * 0.4 + orthogonalToWallVec.x() * (player.getRandom().nextDouble() - 0.5D)) * width, pos.y() + 0.1D + 0.3 * player.getRandom().nextDouble(), pos.z() + (wallDirection.z() * 0.4 + orthogonalToWallVec.z() * (player.getRandom().nextDouble() - 0.5D)) * width ); - Vector3d particleSpeed = particleBaseDirection + Vec3Wrapper particleSpeed = particleBaseDirection .yRot((float) (Math.PI * 0.2 * (player.getRandom().nextDouble() - 0.5))) .scale(3 + 6 * player.getRandom().nextDouble()) .add(0, 1.5, 0); diff --git a/src/main/java/com/alrex/parcool/common/action/impl/QuickTurn.java b/src/main/java/com/alrex/parcool/common/action/impl/QuickTurn.java index b61910ad..6bd02817 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/QuickTurn.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/QuickTurn.java @@ -1,13 +1,13 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.input.KeyRecorder; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.StaminaConsumeTiming; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.event.TickEvent; import java.nio.ByteBuffer; @@ -15,11 +15,11 @@ public class QuickTurn extends Action { private static final int AnimationTickLength = 4; private boolean turnRightward = false; - private Vector3d startAngle = null; + private Vec3Wrapper startAngle = null; @Override public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { - Vector3d angle = player.getLookAngle(); + Vec3Wrapper angle = player.getLookAngle(); startInfo .putDouble(angle.x()) .putDouble(angle.z()); @@ -38,7 +38,7 @@ public boolean canContinue(PlayerWrapper player, Parkourability parkourability, @Override public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { turnRightward = !turnRightward; - startAngle = new Vector3d( + startAngle = new Vec3Wrapper( startData.getDouble(), 0, startData.getDouble() @@ -50,7 +50,7 @@ public void onRenderTick(TickEvent.RenderTickEvent event, PlayerWrapper player, if (isDoing() && startAngle != null) { float renderTick = getDoingTick() + event.renderTickTime; float animationPhase = renderTick / AnimationTickLength; - Vector3d rotatedAngle = startAngle.yRot((float) (Math.PI * animationPhase * (turnRightward ? -1 : 1))); + Vec3Wrapper rotatedAngle = startAngle.yRot((float) (Math.PI * animationPhase * (turnRightward ? -1 : 1))); player.setYRot(VectorUtil.toYawDegree(rotatedAngle)); } } diff --git a/src/main/java/com/alrex/parcool/common/action/impl/RideZipline.java b/src/main/java/com/alrex/parcool/common/action/impl/RideZipline.java index 61753b1a..442d25ea 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/RideZipline.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/RideZipline.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.RideZiplineAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -15,7 +16,6 @@ import com.alrex.parcool.utilities.BufferUtil; import com.alrex.parcool.utilities.VectorUtil; import net.minecraft.util.math.MathHelper; -import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.common.ForgeMod; import javax.annotation.Nullable; @@ -27,13 +27,13 @@ public class RideZipline extends Action { @Nullable private ZiplineRopeEntity ridingZipline; @Nullable - private Vector3d endOffsetFromStart; + private Vec3Wrapper endOffsetFromStart; private double speed; private double acceleration; private double slope; private float currentT; @Nullable - private Vector3d currentPos; + private Vec3Wrapper currentPos; public double getAcceleration() { return acceleration; @@ -44,7 +44,7 @@ public double getSlope() { } @Nullable - public Vector3d getEndOffsetFromStart() { + public Vec3Wrapper getEndOffsetFromStart() { return endOffsetFromStart; } @@ -135,18 +135,18 @@ public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability park speed *= 0.98; if (player.isInWater()) speed *= 0.8; speed -= gravity * slope * (MathHelper.fastInvSqrt(slope * slope + 1)); - Vector3d input = new Vector3d( + Vec3Wrapper input = new Vec3Wrapper( (KeyBindings.isKeyRightDown() ? 1. : 0.) + (KeyBindings.isKeyLeftDown() ? -1. : 0.), 0., (KeyBindings.isKeyForwardDown() ? 1. : 0.) + (KeyBindings.isKeyBackDown() ? -1. : 0.) ); - Vector3d offset = zipline.getOffsetToEndFromStart(); + Vec3Wrapper offset = zipline.getOffsetToEndFromStart(); if (input.lengthSqr() > 0.01) { double dot = player.getLookAngle() .yRot((float) Math.toRadians(VectorUtil.toYawDegree(input))) .multiply(1, 0, 1) .normalize() - .dot(new Vector3d(offset.x(), 0, offset.z()).normalize()); + .dot(new Vec3Wrapper(offset.x(), 0, offset.z()).normalize()); speed += dot * 0.01; } currentT = (float) zipline.getMovedPositionByParameterApproximately(currentT, (float) speed); @@ -154,34 +154,34 @@ public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability park currentPos = zipline.getMidPoint(currentT); } - private void rideNewZipline(ZiplineRopeEntity ziplineRopeEntity, Vector3d position, Vector3d deltaMovement) { + private void rideNewZipline(ZiplineRopeEntity ziplineRopeEntity, Vec3Wrapper position, Vec3Wrapper deltaMovement) { ridingZipline = ziplineRopeEntity; Zipline zipline = ziplineRopeEntity.getZipline(); acceleration = 0; currentT = MathHelper.clamp(zipline.getParameter(position), 0, 1); currentPos = zipline.getMidPoint(currentT); slope = zipline.getSlope(currentT); - Vector3d speedScale; + Vec3Wrapper speedScale; { float yScale = (float) slope; - Vector3d pointsOffset = zipline.getOffsetToEndFromStart(); + Vec3Wrapper pointsOffset = zipline.getOffsetToEndFromStart(); double xzLenInvSqrt = MathHelper.fastInvSqrt(pointsOffset.x() * pointsOffset.x() + pointsOffset.z() * pointsOffset.z()); double xScale = pointsOffset.x() * xzLenInvSqrt; double zScale = pointsOffset.z() * xzLenInvSqrt; - speedScale = new Vector3d(xScale, yScale, zScale).normalize(); + speedScale = new Vec3Wrapper(xScale, yScale, zScale).normalize(); } speed = deltaMovement.dot(speedScale); } - private static Vector3d getDeltaMovement(Zipline zipline, double speed, float currentT) { - Vector3d speedScale; + private static Vec3Wrapper getDeltaMovement(Zipline zipline, double speed, float currentT) { + Vec3Wrapper speedScale; { float yScale = zipline.getSlope(currentT); - Vector3d pointsOffset = zipline.getOffsetToEndFromStart(); + Vec3Wrapper pointsOffset = zipline.getOffsetToEndFromStart(); double xzLenInvSqrt = MathHelper.fastInvSqrt(pointsOffset.x() * pointsOffset.x() + pointsOffset.z() * pointsOffset.z()); double xScale = pointsOffset.x() * xzLenInvSqrt; double zScale = pointsOffset.z() * xzLenInvSqrt; - speedScale = new Vector3d(xScale, yScale, zScale).normalize(); + speedScale = new Vec3Wrapper(xScale, yScale, zScale).normalize(); } return speedScale.scale(speed); } @@ -201,7 +201,7 @@ public void restoreSynchronizedState(ByteBuffer buffer) { @Override public void onWorkingTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { player.resetFallDistance(); - player.setDeltaMovement(Vector3d.ZERO); + player.setDeltaMovement(Vec3Wrapper.ZERO); } @Override diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Roll.java b/src/main/java/com/alrex/parcool/common/action/impl/Roll.java index 23cb03f2..f8582fd3 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Roll.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Roll.java @@ -2,6 +2,7 @@ import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.RollAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; @@ -12,7 +13,6 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -89,7 +89,7 @@ public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourabi startRequired = false; Direction direction = Direction.values()[startData.getInt()]; double modifier = Math.sqrt(player.getBbWidth()); - Vector3d vec = VectorUtil.fromYawDegree(player.getYBodyRot()).scale(modifier); + Vec3Wrapper vec = VectorUtil.fromYawDegree(player.getYBodyRot()).scale(modifier); switch (direction) { case Back: vec = vec.reverse(); diff --git a/src/main/java/com/alrex/parcool/common/action/impl/SkyDive.java b/src/main/java/com/alrex/parcool/common/action/impl/SkyDive.java index 89a15dc7..9818e002 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/SkyDive.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/SkyDive.java @@ -2,13 +2,13 @@ import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.input.KeyRecorder; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.StaminaConsumeTiming; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.utilities.VectorUtil; -import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.event.TickEvent; import java.nio.ByteBuffer; @@ -31,8 +31,8 @@ public boolean canContinue(PlayerWrapper player, Parkourability parkourability, public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { if (!player.isLocalPlayer()) return; ClientPlayerWrapper clientPlayer = ClientPlayerWrapper.get(player); - Vector3d forwardVec = VectorUtil.fromYawDegree(player.getYHeadRot()); - Vector3d leftVec = forwardVec.yRot((float) Math.PI / 2).scale(clientPlayer.getLeftImpulse() * 0.0); + Vec3Wrapper forwardVec = VectorUtil.fromYawDegree(player.getYHeadRot()); + Vec3Wrapper leftVec = forwardVec.yRot((float) Math.PI / 2).scale(clientPlayer.getLeftImpulse() * 0.0); forwardVec = forwardVec.scale(clientPlayer.getForwardImpulse() * 0.03); clientPlayer.setDeltaMovement(clientPlayer.getDeltaMovement() .multiply(1, 0.98, 1).add( diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Slide.java b/src/main/java/com/alrex/parcool/common/action/impl/Slide.java index 7b0f3817..b38b2066 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Slide.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Slide.java @@ -2,6 +2,7 @@ import com.alrex.parcool.api.SoundEvents; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.CrawlAnimator; import com.alrex.parcool.client.animation.impl.SlidingAnimator; import com.alrex.parcool.client.input.KeyRecorder; @@ -19,7 +20,6 @@ import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -29,11 +29,11 @@ public class Slide extends Action { private static final BehaviorEnforcer.ID ID_JUMP_CANCEL = BehaviorEnforcer.newID(); - private Vector3d slidingVec = null; + private Vec3Wrapper slidingVec = null; @Override public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { - Vector3d lookingVec = player.getLookAngle().multiply(1, 0, 1).normalize(); + Vec3Wrapper lookingVec = player.getLookAngle().multiply(1, 0, 1).normalize(); startInfo.putDouble(lookingVec.x()).putDouble(lookingVec.z()); return (!stamina.isExhausted() && KeyRecorder.keyCrawlState.isPressed() @@ -58,7 +58,7 @@ public boolean canContinue(PlayerWrapper player, Parkourability parkourability, @Override public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { - slidingVec = new Vector3d(startData.getDouble(), 0, startData.getDouble()); + slidingVec = new Vec3Wrapper(startData.getDouble(), 0, startData.getDouble()); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.SLIDE.get(), 1f, 1f); Animation animation = Animation.get(player); @@ -70,7 +70,7 @@ public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourabi @Override public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { - slidingVec = new Vector3d(startData.getDouble(), 0, startData.getDouble()); + slidingVec = new Vec3Wrapper(startData.getDouble(), 0, startData.getDouble()); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.SLIDE.get(), 1f, 1f); Animation animation = Animation.get(player); @@ -87,7 +87,7 @@ public void onWorkingTickInLocalClient(PlayerWrapper player, Parkourability park if (attr != null) { speedScale = attr.getValue() * 4.5; } - Vector3d vec = slidingVec.scale(speedScale); + Vec3Wrapper vec = slidingVec.scale(speedScale); player.setDeltaMovement((player.isOnGround() ? vec : vec.scale(0.6)).add(0, player.getDeltaMovement().y(), 0)); } } @@ -114,7 +114,7 @@ public void onStopInOtherClient(PlayerWrapper player) { } @Nullable - public Vector3d getSlidingVector() { + public Vec3Wrapper getSlidingVector() { return slidingVec; } @@ -127,19 +127,19 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { private void spawnSlidingParticle(PlayerWrapper player) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; World level = player.getLevel(); - Vector3d pos = player.position(); + Vec3Wrapper pos = player.position(); BlockState feetBlock = player.getBelowBlockState(); float width = player.getBbWidth(); - Vector3d direction = getSlidingVector(); + Vec3Wrapper direction = getSlidingVector(); if (direction == null) return; if (feetBlock.getRenderShape() != BlockRenderType.INVISIBLE) { - Vector3d particlePos = new Vector3d( + Vec3Wrapper particlePos = new Vec3Wrapper( pos.x() + (player.getRandom().nextDouble() - 0.5D) * width, pos.y() + 0.01D + 0.2 * player.getRandom().nextDouble(), pos.z() + (player.getRandom().nextDouble() - 0.5D) * width ); - Vector3d particleSpeed = direction + Vec3Wrapper particleSpeed = direction .reverse() .scale(2.5 + 5 * player.getRandom().nextDouble()) .add(0, 1.5, 0); diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Vault.java b/src/main/java/com/alrex/parcool/common/action/impl/Vault.java index b2ae39be..fbc58153 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Vault.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Vault.java @@ -2,6 +2,7 @@ import com.alrex.parcool.api.SoundEvents; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.KongVaultAnimator; import com.alrex.parcool.client.animation.impl.SpeedVaultAnimator; import com.alrex.parcool.client.input.KeyBindings; @@ -12,7 +13,6 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.WorldUtil; -import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -31,7 +31,7 @@ public enum AnimationType { //only in client private double stepHeight = 0; - private Vector3d stepDirection = null; + private Vec3Wrapper stepDirection = null; @Nullable private AnimationType currentAnimation; @@ -44,14 +44,14 @@ public AnimationType getCurrentAnimation() { @OnlyIn(Dist.CLIENT) @Override public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { - Vector3d lookVec = player.getLookAngle(); - lookVec = new Vector3d(lookVec.x(), 0, lookVec.z()).normalize(); - Vector3d step = WorldUtil.getVaultableStep(player); + Vec3Wrapper lookVec = player.getLookAngle(); + lookVec = new Vec3Wrapper(lookVec.x(), 0, lookVec.z()).normalize(); + Vec3Wrapper step = WorldUtil.getVaultableStep(player); if (step == null) return false; step = step.normalize(); //doing "vec/stepDirection" as complex number(x + z i) to calculate difference of player's direction to steps - Vector3d dividedVec = - new Vector3d( + Vec3Wrapper dividedVec = + new Vec3Wrapper( lookVec.x() * step.x() + lookVec.z() * step.z(), 0, -lookVec.x() * step.z() + lookVec.z() * step.x() ).normalize(); @@ -106,7 +106,7 @@ public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourabi currentAnimation = AnimationType.values()[startData.get()]; if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.VAULT.get(), 1f, 1f); - stepDirection = new Vector3d(startData.getDouble(), startData.getDouble(), startData.getDouble()); + stepDirection = new Vec3Wrapper(startData.getDouble(), startData.getDouble(), startData.getDouble()); stepHeight = startData.getDouble(); Animation animation = Animation.get(player); if (animation != null && currentAnimation != null) { diff --git a/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java b/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java index e98fc8af..727bcaf1 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java @@ -2,6 +2,7 @@ import com.alrex.parcool.api.SoundEvents; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.VerticalWallRunAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; @@ -17,7 +18,6 @@ import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -27,7 +27,7 @@ public class VerticalWallRun extends Action { private double playerYSpeed = 0; - private Vector3d wallDirection = null; + private Vec3Wrapper wallDirection = null; @Override public void onTick(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { @@ -37,7 +37,7 @@ public void onTick(PlayerWrapper player, Parkourability parkourability, IStamina @Override public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { int tickAfterJump = parkourability.getAdditionalProperties().getTickAfterLastJump(); - Vector3d lookVec = player.getLookAngle(); + Vec3Wrapper lookVec = player.getLookAngle(); boolean able = !stamina.isExhausted() && (Math.abs(player.getDeltaMovement().y()) <= player.getBbHeight() / 5) && (4 < tickAfterJump && tickAfterJump < 13) @@ -55,7 +55,7 @@ && getNotDoingTick() > 15 && parkourability.getAdditionalProperties().getLastSprintingTick() > 12 && lookVec.y() > 0; if (able) { - Vector3d wall = WorldUtil.getWall(player); + Vec3Wrapper wall = WorldUtil.getWall(player); if (wall == null) return false; wall = wall.normalize(); if (wall.dot(VectorUtil.fromYawDegree(player.getYHeadRot())) > 0.93) { @@ -82,7 +82,7 @@ && getNotDoingTick() > 15 @Override public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { - Vector3d wall = WorldUtil.getWall(player); + Vec3Wrapper wall = WorldUtil.getWall(player); if (wall == null) return false; wall = wall.normalize(); return (wall.dot(VectorUtil.fromYawDegree(player.getYHeadRot())) > 0.93 @@ -107,7 +107,7 @@ public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourabi @Override public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { startData.position(8 + 4); // skip (double * 1) and (float * 1) - wallDirection = new Vector3d(startData.getDouble(), startData.getDouble(), startData.getDouble()); + wallDirection = new Vec3Wrapper(startData.getDouble(), startData.getDouble(), startData.getDouble()); if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.VERTICAL_WALL_RUN.get(), 1f, 1f); Animation animation = Animation.get(player); @@ -139,7 +139,7 @@ public void spawnRunningParticle(PlayerWrapper player) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; if (wallDirection == null) return; World level = player.getLevel(); - Vector3d pos = player.position(); + Vec3Wrapper pos = player.position(); BlockPos leanedBlock = new BlockPos( pos.add(wallDirection.x(), player.getBbHeight() * 0.25, wallDirection.z()) ); @@ -147,15 +147,15 @@ public void spawnRunningParticle(PlayerWrapper player) { float width = player.getBbWidth(); BlockState blockstate = level.getBlockState(leanedBlock); - Vector3d normalizedWallVec = wallDirection.normalize(); - Vector3d orthogonalToWallVec = normalizedWallVec.yRot((float) (Math.PI / 2)); + Vec3Wrapper normalizedWallVec = wallDirection.normalize(); + Vec3Wrapper orthogonalToWallVec = normalizedWallVec.yRot((float) (Math.PI / 2)); if (blockstate.getRenderShape() != BlockRenderType.INVISIBLE) { - Vector3d particlePos = new Vector3d( + Vec3Wrapper particlePos = new Vec3Wrapper( pos.x() + (normalizedWallVec.x() * 0.4 + orthogonalToWallVec.x() * (player.getRandom().nextDouble() - 0.5D)) * width, pos.y() + 0.1D + 0.3 * player.getRandom().nextDouble(), pos.z() + (normalizedWallVec.z() * 0.4 + orthogonalToWallVec.z() * (player.getRandom().nextDouble() - 0.5D)) * width ); - Vector3d particleSpeed = normalizedWallVec + Vec3Wrapper particleSpeed = normalizedWallVec .reverse() .yRot((float) (Math.PI * 0.2 * (player.getRandom().nextDouble() - 0.5))) .scale(2 + 4 * player.getRandom().nextDouble()) diff --git a/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java b/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java index 1e14efcb..312154ca 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java @@ -2,6 +2,7 @@ import com.alrex.parcool.api.SoundEvents; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.BackwardWallJumpAnimator; import com.alrex.parcool.client.animation.impl.WallJumpAnimator; import com.alrex.parcool.client.input.KeyRecorder; @@ -17,7 +18,6 @@ import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -56,12 +56,12 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { @OnlyIn(Dist.CLIENT) @Nullable - private Vector3d getJumpDirection(PlayerWrapper player, Vector3d wall) { + private Vec3Wrapper getJumpDirection(PlayerWrapper player, Vec3Wrapper wall) { if (wall == null) return null; wall = wall.normalize(); - Vector3d lookVec = player.getLookAngle(); - Vector3d vec = new Vector3d(lookVec.x(), 0, lookVec.z()).normalize(); - Vector3d value; + Vec3Wrapper lookVec = player.getLookAngle(); + Vec3Wrapper vec = new Vec3Wrapper(lookVec.x(), 0, lookVec.z()).normalize(); + Vec3Wrapper value; double dotProduct = wall.dot(vec); if (dotProduct > -Math.cos(Math.toRadians(ParCoolConfig.Client.Integers.AcceptableAngleOfWallJump.get()))) { @@ -79,8 +79,8 @@ private Vector3d getJumpDirection(PlayerWrapper player, Vector3d wall) { @Override public boolean canStart(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startInfo) { - Vector3d wallDirection = WorldUtil.getWall(player, player.getBbWidth() * 0.65); - Vector3d jumpDirection = getJumpDirection(player, wallDirection); + Vec3Wrapper wallDirection = WorldUtil.getWall(player, player.getBbWidth() * 0.65); + Vec3Wrapper jumpDirection = getJumpDirection(player, wallDirection); if (jumpDirection == null) return false; ClingToCliff cling = parkourability.get(ClingToCliff.class); ControlType control = ParCoolConfig.Client.WallJumpControl.get(); @@ -102,14 +102,14 @@ public boolean canStart(PlayerWrapper player, Parkourability parkourability, ISt if (!value) return false; //doing "wallDirection/jumpDirection" as complex number(x + z i) to calculate difference of player's direction to wall - Vector3d dividedVec = - new Vector3d( + Vec3Wrapper dividedVec = + new Vec3Wrapper( wallDirection.x() * jumpDirection.x() + wallDirection.z() * jumpDirection.z(), 0, -wallDirection.x() * jumpDirection.z() + wallDirection.z() * jumpDirection.x() ).normalize(); - Vector3d lookVec = player.getLookAngle().multiply(1, 0, 1).normalize(); - Vector3d lookDividedVec = - new Vector3d( + Vec3Wrapper lookVec = player.getLookAngle().multiply(1, 0, 1).normalize(); + Vec3Wrapper lookDividedVec = + new Vec3Wrapper( lookVec.x() * wallDirection.x() + lookVec.z() * wallDirection.z(), 0, -lookVec.x() * wallDirection.z() + lookVec.z() * wallDirection.x() ).normalize(); @@ -154,10 +154,10 @@ public void onStart(PlayerWrapper player, Parkourability parkourability, ByteBuf public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourability, IStamina stamina, ByteBuffer startData) { if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.WALL_JUMP.get(), 1f, 1f); - Vector3d jumpDirection = new Vector3d(startData.getDouble(), startData.getDouble(), startData.getDouble()); - Vector3d jumpMotion = jumpDirection.scale(0.59); - Vector3d wallDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); - Vector3d motion = player.getDeltaMovement(); + Vec3Wrapper jumpDirection = new Vec3Wrapper(startData.getDouble(), startData.getDouble(), startData.getDouble()); + Vec3Wrapper jumpMotion = jumpDirection.scale(0.59); + Vec3Wrapper wallDirection = new Vec3Wrapper(startData.getDouble(), 0, startData.getDouble()); + Vec3Wrapper motion = player.getDeltaMovement(); BlockPos leanedBlock = new BlockPos( player.getX() + wallDirection.x(), @@ -201,8 +201,8 @@ public void onStartInLocalClient(PlayerWrapper player, Parkourability parkourabi public void onStartInOtherClient(PlayerWrapper player, Parkourability parkourability, ByteBuffer startData) { if (ParCoolConfig.Client.Booleans.EnableActionSounds.get()) player.playSound(SoundEvents.WALL_JUMP.get(), 1f, 1f); - Vector3d jumpDirection = new Vector3d(startData.getDouble(), startData.getDouble(), startData.getDouble()); - Vector3d wallDirection = new Vector3d(startData.getDouble(), 0, startData.getDouble()); + Vec3Wrapper jumpDirection = new Vec3Wrapper(startData.getDouble(), startData.getDouble(), startData.getDouble()); + Vec3Wrapper wallDirection = new Vec3Wrapper(startData.getDouble(), 0, startData.getDouble()); BlockPos leanedBlock = new BlockPos( player.getX() + wallDirection.x(), player.getBoundingBox().minY + player.getBbHeight() * 0.25, @@ -237,10 +237,10 @@ public void onWorkingTickInClient(PlayerWrapper player, Parkourability parkourab } @OnlyIn(Dist.CLIENT) - private void spawnJumpParticles(PlayerWrapper player, Vector3d wallDirection, Vector3d jumpDirection) { + private void spawnJumpParticles(PlayerWrapper player, Vec3Wrapper wallDirection, Vec3Wrapper jumpDirection) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; World level = player.getLevel(); - Vector3d pos = player.position(); + Vec3Wrapper pos = player.position(); BlockPos leanedBlock = new BlockPos( pos.add(wallDirection.x(), player.getBbHeight() * 0.25, wallDirection.z()) ); @@ -248,30 +248,30 @@ private void spawnJumpParticles(PlayerWrapper player, Vector3d wallDirection, Ve float width = player.getBbWidth(); BlockState blockstate = level.getBlockState(leanedBlock); - Vector3d horizontalJumpDirection = jumpDirection.multiply(1, 0, 1).normalize(); + Vec3Wrapper horizontalJumpDirection = jumpDirection.multiply(1, 0, 1).normalize(); wallDirection = wallDirection.normalize(); - Vector3d orthogonalToWallVec = wallDirection.yRot((float) (Math.PI / 2)).normalize(); + Vec3Wrapper orthogonalToWallVec = wallDirection.yRot((float) (Math.PI / 2)).normalize(); //doing "Conjugate of (horizontalJumpDirection/-wallDirection)" as complex number(x + z i) - Vector3d differenceVec = - new Vector3d( + Vec3Wrapper differenceVec = + new Vec3Wrapper( -wallDirection.x() * horizontalJumpDirection.x() - wallDirection.z() * horizontalJumpDirection.z(), 0, wallDirection.z() * horizontalJumpDirection.x() - wallDirection.x() * horizontalJumpDirection.z() ).multiply(1, 0, -1).normalize(); - Vector3d particleBaseDirection = - new Vector3d( + Vec3Wrapper particleBaseDirection = + new Vec3Wrapper( -wallDirection.x() * differenceVec.x() + wallDirection.z() * differenceVec.z(), 0, -wallDirection.x() * differenceVec.z() - wallDirection.z() * differenceVec.x() ); if (blockstate.getRenderShape() != BlockRenderType.INVISIBLE) { for (int i = 0; i < 10; i++) { - Vector3d particlePos = new Vector3d( + Vec3Wrapper particlePos = new Vec3Wrapper( pos.x() + (wallDirection.x() * 0.4 + orthogonalToWallVec.x() * (player.getRandom().nextDouble() - 0.5D)) * width, pos.y() + 0.1D + 0.3 * player.getRandom().nextDouble(), pos.z() + (wallDirection.z() * 0.4 + orthogonalToWallVec.z() * (player.getRandom().nextDouble() - 0.5D)) * width ); - Vector3d particleSpeed = particleBaseDirection + Vec3Wrapper particleSpeed = particleBaseDirection .yRot((float) (Math.PI * 0.2 * (player.getRandom().nextDouble() - 0.5))) .scale(3 + 9 * player.getRandom().nextDouble()) .add(0, -jumpDirection.y() * 3 * player.getRandom().nextDouble(), 0); diff --git a/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java b/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java index 882e95ad..e08e2927 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.WallSlideAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; @@ -16,7 +17,6 @@ import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -25,14 +25,14 @@ import java.nio.ByteBuffer; public class WallSlide extends Action { - private Vector3d leanedWallDirection = null; + private Vec3Wrapper leanedWallDirection = null; private byte particleSpawnCoolTime = 0; private double startYSpeed = 0; private int damageCount = 0, takenDamageCount = 0; private byte damageCoolTime = 0; @Nullable - public Vector3d getLeanedWallDirection() { + public Vec3Wrapper getLeanedWallDirection() { return leanedWallDirection; } @@ -45,7 +45,7 @@ public boolean canStart(PlayerWrapper player, Parkourability parkourability, ISt @Override public boolean canContinue(PlayerWrapper player, Parkourability parkourability, IStamina stamina) { - Vector3d wall = WorldUtil.getWall(player); + Vec3Wrapper wall = WorldUtil.getWall(player); return (wall != null && !player.isOnGround() && !parkourability.get(FastRun.class).isDoing() @@ -125,7 +125,7 @@ private void spawnSlideParticle(PlayerWrapper player) { if (leanedWallDirection == null) return; if (player.getRandom().nextBoolean()) return; World level = player.getLevel(); - Vector3d pos = player.position(); + Vec3Wrapper pos = player.position(); BlockPos leanedBlock = new BlockPos( pos.add(leanedWallDirection.x(), player.getBbHeight() * 0.25, leanedWallDirection.z()) ); @@ -133,15 +133,15 @@ private void spawnSlideParticle(PlayerWrapper player) { float width = player.getBbWidth(); BlockState blockstate = level.getBlockState(leanedBlock); - Vector3d normalizedWallVec = leanedWallDirection.normalize(); - Vector3d orthogonalToWallVec = normalizedWallVec.yRot((float) (Math.PI / 2)); + Vec3Wrapper normalizedWallVec = leanedWallDirection.normalize(); + Vec3Wrapper orthogonalToWallVec = normalizedWallVec.yRot((float) (Math.PI / 2)); if (blockstate.getRenderShape() != BlockRenderType.INVISIBLE) { - Vector3d particlePos = new Vector3d( + Vec3Wrapper particlePos = new Vec3Wrapper( pos.x() + (normalizedWallVec.x() * 0.4 + orthogonalToWallVec.x() * (player.getRandom().nextDouble() - 0.5D)) * width, pos.y() + player.getBbHeight() - 0.2D + 0.3 * player.getRandom().nextDouble(), pos.z() + (normalizedWallVec.z() * 0.4 + orthogonalToWallVec.z() * (player.getRandom().nextDouble() - 0.5D)) * width ); - Vector3d particleSpeed = normalizedWallVec + Vec3Wrapper particleSpeed = normalizedWallVec .reverse() .yRot((float) (Math.PI * 0.1 * (player.getRandom().nextDouble() - 0.5))) .scale(0.05) diff --git a/src/main/java/com/alrex/parcool/common/block/zipline/IronZiplineHookBlock.java b/src/main/java/com/alrex/parcool/common/block/zipline/IronZiplineHookBlock.java index 744d480b..0de23ad1 100644 --- a/src/main/java/com/alrex/parcool/common/block/zipline/IronZiplineHookBlock.java +++ b/src/main/java/com/alrex/parcool/common/block/zipline/IronZiplineHookBlock.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.block.zipline; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.block.BlockStateProperties; import net.minecraft.block.Block; import net.minecraft.block.BlockState; @@ -11,7 +12,6 @@ import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.shapes.ISelectionContext; import net.minecraft.util.math.shapes.VoxelShape; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.IBlockReader; public class IronZiplineHookBlock extends ZiplineHookBlock { @@ -50,9 +50,9 @@ public IronZiplineHookBlock(Properties p_i48440_1_) { } @Override - public Vector3d getActualZiplinePoint(BlockPos pos, BlockState state) { + public Vec3Wrapper getActualZiplinePoint(BlockPos pos, BlockState state) { Direction direction = state.getValue(FACING); - return new Vector3d( + return new Vec3Wrapper( pos.getX() + 0.5 - direction.getStepX() * 0.2, pos.getY() + 0.5 - direction.getStepY() * 0.2, pos.getZ() + 0.5 - direction.getStepZ() * 0.2 @@ -74,7 +74,7 @@ public BlockState getStateForPlacement(BlockItemUseContext context) { if (player == null) orthogonal = false; else { - Vector3d lookVec = player.getLookAngle(); + Vec3Wrapper lookVec = player.getLookAngle(); switch (context.getClickedFace()) { case NORTH: case SOUTH: diff --git a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java index 52561665..ec9078c2 100644 --- a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java +++ b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java @@ -2,6 +2,7 @@ import com.alrex.parcool.api.SoundEvents; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.block.TileEntities; import net.minecraft.block.Block; import net.minecraft.block.BlockState; @@ -21,7 +22,6 @@ import net.minecraft.util.Hand; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.BlockRayTraceResult; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.IBlockReader; import net.minecraft.world.IWorld; import net.minecraft.world.IWorldReader; @@ -38,8 +38,8 @@ public ZiplineHookBlock(Properties p_i48440_1_) { registerDefaultState(defaultBlockState().setValue(FACING, Direction.UP)); } - public Vector3d getActualZiplinePoint(BlockPos pos, BlockState state) { - return new Vector3d(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5); + public Vec3Wrapper getActualZiplinePoint(BlockPos pos, BlockState state) { + return new Vec3Wrapper(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5); } @Override diff --git a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookTileEntity.java b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookTileEntity.java index 067ce606..714a878b 100644 --- a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookTileEntity.java +++ b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookTileEntity.java @@ -1,5 +1,6 @@ package com.alrex.parcool.common.block.zipline; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.entity.zipline.ZiplineRopeEntity; import com.alrex.parcool.common.item.Items; import com.alrex.parcool.common.item.zipline.ZiplineRopeItem; @@ -13,7 +14,6 @@ import net.minecraft.tileentity.TileEntity; import net.minecraft.tileentity.TileEntityType; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.World; import javax.annotation.Nonnull; @@ -86,15 +86,15 @@ public void onChunkUnloaded() { } } - public Vector3d getActualZiplinePoint(@Nullable BlockPos connected) { + public Vec3Wrapper getActualZiplinePoint(@Nullable BlockPos connected) { if (level == null) - new Vector3d(getBlockPos().getX() + 0.5, getBlockPos().getY() + 0.5, getBlockPos().getZ() + 0.5); + new Vec3Wrapper(getBlockPos().getX() + 0.5, getBlockPos().getY() + 0.5, getBlockPos().getZ() + 0.5); BlockState state = level.getBlockState(this.getBlockPos()); Block block = state.getBlock(); if (block instanceof ZiplineHookBlock) { return ((ZiplineHookBlock) block).getActualZiplinePoint(this.getBlockPos(), state); } - return new Vector3d(getBlockPos().getX() + 0.5, getBlockPos().getY() + 0.5, getBlockPos().getZ() + 0.5); + return new Vec3Wrapper(getBlockPos().getX() + 0.5, getBlockPos().getY() + 0.5, getBlockPos().getZ() + 0.5); } public boolean connectTo(ZiplineHookTileEntity target, ZiplineInfo info) { diff --git a/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java b/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java index cd8f1227..f58af6a3 100644 --- a/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java +++ b/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.entity.zipline; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.block.zipline.ZiplineHookTileEntity; import com.alrex.parcool.common.block.zipline.ZiplineInfo; import com.alrex.parcool.common.item.zipline.ZiplineRopeItem; @@ -20,7 +21,6 @@ import net.minecraft.util.ActionResultType; import net.minecraft.util.Hand; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.World; import net.minecraftforge.fml.network.NetworkHooks; @@ -73,19 +73,19 @@ public Zipline getZipline() { zipline_start = start; zipline_end = end; zip_type = type; - Vector3d startPos; - Vector3d endPos; + Vec3Wrapper startPos; + Vec3Wrapper endPos; TileEntity startEntity = level.getBlockEntity(start); TileEntity endEntity = level.getBlockEntity(end); if (startEntity instanceof ZiplineHookTileEntity) { startPos = ((ZiplineHookTileEntity) startEntity).getActualZiplinePoint(end); } else { - startPos = new Vector3d(start.getX() + 0.5, start.getY() + 0.7, start.getZ() + 0.5); + startPos = new Vec3Wrapper(start.getX() + 0.5, start.getY() + 0.7, start.getZ() + 0.5); } if (endEntity instanceof ZiplineHookTileEntity) { endPos = ((ZiplineHookTileEntity) endEntity).getActualZiplinePoint(start); } else { - endPos = new Vector3d(end.getX() + 0.5, end.getY() + 0.7, end.getZ() + 0.5); + endPos = new Vec3Wrapper(end.getX() + 0.5, end.getY() + 0.7, end.getZ() + 0.5); } zipline = type.getZipline(startPos, endPos); } @@ -107,7 +107,7 @@ public boolean shouldRender(double x, double y, double z) { double baseYOffset = start.getY() - y; double baseZOffset = start.getZ() - z; double t = -(xOffset * baseXOffset + yOffset * baseYOffset + zOffset * baseZOffset) / (xOffset * xOffset + yOffset * yOffset + zOffset * zOffset); - Vector3d mostNearPoint = new Vector3d(xOffset * t + start.getX(), yOffset * t + start.getY(), zOffset * t + start.getZ()); + Vec3Wrapper mostNearPoint = new Vec3Wrapper(xOffset * t + start.getX(), yOffset * t + start.getY(), zOffset * t + start.getZ()); distanceSqr = mostNearPoint.distanceToSqr(x, y, z); return distanceSqr < Zipline.MAXIMUM_DISTANCE * Zipline.MAXIMUM_DISTANCE; } diff --git a/src/main/java/com/alrex/parcool/common/zipline/Zipline.java b/src/main/java/com/alrex/parcool/common/zipline/Zipline.java index 8fe0700e..566ddf8c 100644 --- a/src/main/java/com/alrex/parcool/common/zipline/Zipline.java +++ b/src/main/java/com/alrex/parcool/common/zipline/Zipline.java @@ -1,10 +1,10 @@ package com.alrex.parcool.common.zipline; import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.entity.zipline.ZiplineRopeEntity; import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.World; import javax.annotation.Nullable; @@ -13,7 +13,7 @@ public abstract class Zipline { public static final double MAXIMUM_DISTANCE = 60.; - protected Zipline(Vector3d point1, Vector3d point2) { + protected Zipline(Vec3Wrapper point1, Vec3Wrapper point2) { if (point1.y() <= point2.y()) { this.startPos = point1; this.endPos = point2; @@ -25,20 +25,20 @@ protected Zipline(Vector3d point1, Vector3d point2) { horizontalDistance = Math.hypot(endOffsetFromStart.x(), endOffsetFromStart.z()); } - private final Vector3d startPos; - private final Vector3d endPos; - private final Vector3d endOffsetFromStart; + private final Vec3Wrapper startPos; + private final Vec3Wrapper endPos; + private final Vec3Wrapper endOffsetFromStart; private final double horizontalDistance; - public Vector3d getStartPos() { + public Vec3Wrapper getStartPos() { return startPos; } - public Vector3d getEndPos() { + public Vec3Wrapper getEndPos() { return endPos; } - public Vector3d getOffsetToEndFromStart() { + public Vec3Wrapper getOffsetToEndFromStart() { return endOffsetFromStart; } @@ -57,7 +57,7 @@ public static ZiplineRopeEntity getHangableZipline(World world, PlayerWrapper pl ZiplineRopeEntity.class, player.getBoundingBox().inflate(MAXIMUM_DISTANCE * 0.52) ); - Vector3d grabPos = player.position().add(0, player.getBbHeight() * 1.11, 0); + Vec3Wrapper grabPos = player.position().add(0, player.getBbHeight() * 1.11, 0); for (ZiplineRopeEntity ziplineEntity : entities) { if (except == ziplineEntity) continue; @@ -78,7 +78,7 @@ public static ZiplineRopeEntity getHangableZipline(World world, PlayerWrapper pl public boolean conflictsWithSomething(World world) { int count = (int) Math.floor(getHorizontalDistance()); for (int i = 1; i < count - 1; i++) { - Vector3d midPoint = getMidPoint(((float) i / count)); + Vec3Wrapper midPoint = getMidPoint(((float) i / count)); final double d = 0.2; if (!world.noCollision(new AxisAlignedBB( midPoint.subtract(d, d, d), @@ -98,11 +98,11 @@ public boolean conflictsWithSomething(World world) { // the x is start.x + (end.x - start.x) * t // also same about z // y is decided by calculated x and z - public Vector3d getMidPoint(float t) { + public Vec3Wrapper getMidPoint(float t) { return getMidPointOffsetFromStart(t).add(getStartPos()); } - public abstract Vector3d getMidPointOffsetFromStart(float t); + public abstract Vec3Wrapper getMidPointOffsetFromStart(float t); // return slope of zipline // equals dy/d(t * sqrt(x^2 * z^2)) @@ -110,13 +110,13 @@ public Vector3d getMidPoint(float t) { public abstract float getSlope(float t); // return t - public abstract float getParameter(Vector3d position); + public abstract float getParameter(Vec3Wrapper position); // public abstract double getMovedPositionByParameterApproximately(float currentT, float movement); // return not accurate distance - public abstract double getSquaredDistanceApproximately(Vector3d position); + public abstract double getSquaredDistanceApproximately(Vec3Wrapper position); - public abstract boolean isPossiblyHangable(Vector3d position); + public abstract boolean isPossiblyHangable(Vec3Wrapper position); } diff --git a/src/main/java/com/alrex/parcool/common/zipline/ZiplineType.java b/src/main/java/com/alrex/parcool/common/zipline/ZiplineType.java index 68659294..3130b03a 100644 --- a/src/main/java/com/alrex/parcool/common/zipline/ZiplineType.java +++ b/src/main/java/com/alrex/parcool/common/zipline/ZiplineType.java @@ -1,8 +1,8 @@ package com.alrex.parcool.common.zipline; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.zipline.impl.GeneralQuadraticCurveZipline; import com.alrex.parcool.common.zipline.impl.StraightZipline; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.util.text.ITextComponent; import net.minecraft.util.text.TranslationTextComponent; @@ -22,7 +22,7 @@ public ITextComponent getTranslationName() { return new TranslationTextComponent(translationID); } - public Zipline getZipline(Vector3d point1, Vector3d point2) { + public Zipline getZipline(Vec3Wrapper point1, Vec3Wrapper point2) { if (this == STRAIGHT) { return new StraightZipline(point1, point2); } else if (this == STANDARD) { diff --git a/src/main/java/com/alrex/parcool/common/zipline/impl/GeneralQuadraticCurveZipline.java b/src/main/java/com/alrex/parcool/common/zipline/impl/GeneralQuadraticCurveZipline.java index ad9d1021..99d09355 100644 --- a/src/main/java/com/alrex/parcool/common/zipline/impl/GeneralQuadraticCurveZipline.java +++ b/src/main/java/com/alrex/parcool/common/zipline/impl/GeneralQuadraticCurveZipline.java @@ -1,12 +1,12 @@ package com.alrex.parcool.common.zipline.impl; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.zipline.Zipline; import net.minecraft.util.math.AxisAlignedBB; -import net.minecraft.util.math.vector.Vector3d; public class GeneralQuadraticCurveZipline extends Zipline { - public GeneralQuadraticCurveZipline(Vector3d point1, Vector3d point2, double lowestPointOffset) { + public GeneralQuadraticCurveZipline(Vec3Wrapper point1, Vec3Wrapper point2, double lowestPointOffset) { super(point1, point2); double straightDistance = Math.hypot(getHorizontalDistance(), getOffsetToEndFromStart().y()); double yOffsetAtVertex = Math.abs(lowestPointOffset); @@ -28,8 +28,8 @@ public GeneralQuadraticCurveZipline(Vector3d point1, Vector3d point2, double low private final double getMidPointOffsetFromStart$a; @Override - public Vector3d getMidPointOffsetFromStart(float t) { - return new Vector3d( + public Vec3Wrapper getMidPointOffsetFromStart(float t) { + return new Vec3Wrapper( getOffsetToEndFromStart().x() * t, getMidPointOffsetFromStart$a * t * (t - 2 * tAtVertex), getOffsetToEndFromStart().z() * t @@ -42,7 +42,7 @@ public float getSlope(float t) { } @Override - public float getParameter(Vector3d position) { + public float getParameter(Vec3Wrapper position) { double offsetX = getOffsetToEndFromStart().x(); double offsetZ = getOffsetToEndFromStart().z(); return (float) (((position.x() - getStartPos().x()) * offsetX + (position.z() - getStartPos().z()) * offsetZ) / @@ -98,14 +98,14 @@ public double getMovedPositionByParameterApproximately(float currentT, float mov } @Override - public double getSquaredDistanceApproximately(Vector3d position) { + public double getSquaredDistanceApproximately(Vec3Wrapper position) { float t = getParameter(position); - Vector3d simplifiedNearestPoint = getMidPoint(t); + Vec3Wrapper simplifiedNearestPoint = getMidPoint(t); return position.distanceToSqr(simplifiedNearestPoint); } @Override - public boolean isPossiblyHangable(Vector3d position) { + public boolean isPossiblyHangable(Vec3Wrapper position) { return new AxisAlignedBB(getStartPos().x(), getMidPoint((float) tAtVertex).y(), getStartPos().z(), getEndPos().x(), getEndPos().y(), getEndPos().z()) .inflate(0.5) .contains(position); diff --git a/src/main/java/com/alrex/parcool/common/zipline/impl/QuadraticCurveZipline.java b/src/main/java/com/alrex/parcool/common/zipline/impl/QuadraticCurveZipline.java index 88d5e536..ec81ec01 100644 --- a/src/main/java/com/alrex/parcool/common/zipline/impl/QuadraticCurveZipline.java +++ b/src/main/java/com/alrex/parcool/common/zipline/impl/QuadraticCurveZipline.java @@ -1,20 +1,20 @@ package com.alrex.parcool.common.zipline.impl; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.zipline.Zipline; import net.minecraft.util.math.AxisAlignedBB; -import net.minecraft.util.math.vector.Vector3d; public class QuadraticCurveZipline extends Zipline { - public QuadraticCurveZipline(Vector3d point1, Vector3d point2) { + public QuadraticCurveZipline(Vec3Wrapper point1, Vec3Wrapper point2) { super(point1, point2); } @Override - public Vector3d getMidPointOffsetFromStart(float t) { + public Vec3Wrapper getMidPointOffsetFromStart(float t) { double x = getOffsetToEndFromStart().x() * t; double z = getOffsetToEndFromStart().z() * t; double y = getOffsetToEndFromStart().y() * t * t; - return new Vector3d(x, y, z); + return new Vec3Wrapper(x, y, z); } @Override @@ -23,7 +23,7 @@ public float getSlope(float t) { } @Override - public float getParameter(Vector3d position) { + public float getParameter(Vec3Wrapper position) { double offsetX = getOffsetToEndFromStart().x(); double offsetZ = getOffsetToEndFromStart().z(); return (float) (((position.x() - getStartPos().x()) * offsetX + (position.z() - getStartPos().z()) * offsetZ) / @@ -66,20 +66,20 @@ public double getMovedPositionByParameterApproximately(float currentT, float mov } @Override - public double getSquaredDistanceApproximately(Vector3d position) { + public double getSquaredDistanceApproximately(Vec3Wrapper position) { float t = getParameter(position); - Vector3d simplifiedNearestPoint = getMidPoint(t); + Vec3Wrapper simplifiedNearestPoint = getMidPoint(t); return position.distanceToSqr(simplifiedNearestPoint); } @Override - public boolean isPossiblyHangable(Vector3d position) { + public boolean isPossiblyHangable(Vec3Wrapper position) { return new AxisAlignedBB(getStartPos().x(), getStartPos().y(), getStartPos().z(), getEndPos().x(), getEndPos().y(), getEndPos().z()) .inflate(0.5) .contains(position); } - public double getAccurateDistance(Vector3d position) { + public double getAccurateDistance(Vec3Wrapper position) { /* // calculate by minimalize squared distance for t diff --git a/src/main/java/com/alrex/parcool/common/zipline/impl/StraightZipline.java b/src/main/java/com/alrex/parcool/common/zipline/impl/StraightZipline.java index ca3708a9..6fa72890 100644 --- a/src/main/java/com/alrex/parcool/common/zipline/impl/StraightZipline.java +++ b/src/main/java/com/alrex/parcool/common/zipline/impl/StraightZipline.java @@ -1,25 +1,25 @@ package com.alrex.parcool.common.zipline.impl; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.zipline.Zipline; import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.MathHelper; -import net.minecraft.util.math.vector.Vector3d; public class StraightZipline extends Zipline { - public StraightZipline(Vector3d point1, Vector3d point2) { + public StraightZipline(Vec3Wrapper point1, Vec3Wrapper point2) { super(point1, point2); } - public Vector3d getMidPoint(double t) { + public Vec3Wrapper getMidPoint(double t) { return getMidPointOffsetFromStart(t).add(getStartPos()); } @Override - public Vector3d getMidPointOffsetFromStart(float t) { + public Vec3Wrapper getMidPointOffsetFromStart(float t) { return getOffsetToEndFromStart().scale(t); } - public Vector3d getMidPointOffsetFromStart(double t) { + public Vec3Wrapper getMidPointOffsetFromStart(double t) { return getOffsetToEndFromStart().scale(t); } @@ -34,11 +34,11 @@ public float getSlope(float t) { } @Override - public float getParameter(Vector3d position) { + public float getParameter(Vec3Wrapper position) { return (float) getParameterD(position); } - public double getParameterD(Vector3d position) { + public double getParameterD(Vec3Wrapper position) { double xOffset = getOffsetToEndFromStart().x(); double yOffset = getOffsetToEndFromStart().y(); double zOffset = getOffsetToEndFromStart().z(); @@ -55,14 +55,14 @@ public double getMovedPositionByParameterApproximately(float currentT, float mov } @Override - public double getSquaredDistanceApproximately(Vector3d position) { + public double getSquaredDistanceApproximately(Vec3Wrapper position) { double t = getParameterD(position); - Vector3d mostNearPoint = getMidPoint(t); + Vec3Wrapper mostNearPoint = getMidPoint(t); return mostNearPoint.distanceToSqr(position); } @Override - public boolean isPossiblyHangable(Vector3d position) { + public boolean isPossiblyHangable(Vec3Wrapper position) { return new AxisAlignedBB(getStartPos().x(), getStartPos().y(), getStartPos().z(), getEndPos().x(), getEndPos().y(), getEndPos().z()) .inflate(0.5) .contains(position); diff --git a/src/main/java/com/alrex/parcool/mixin/client/ClientPlayerEntityMixin.java b/src/main/java/com/alrex/parcool/mixin/client/ClientPlayerEntityMixin.java index 044a87bc..544d2258 100644 --- a/src/main/java/com/alrex/parcool/mixin/client/ClientPlayerEntityMixin.java +++ b/src/main/java/com/alrex/parcool/mixin/client/ClientPlayerEntityMixin.java @@ -1,6 +1,7 @@ package com.alrex.parcool.mixin.client; import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.capability.Parkourability; import com.mojang.authlib.GameProfile; import net.minecraft.client.entity.player.AbstractClientPlayerEntity; @@ -8,6 +9,7 @@ import net.minecraft.client.world.ClientWorld; import net.minecraft.entity.MoverType; import net.minecraft.util.math.vector.Vector3d; + import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.Shadow; import org.spongepowered.asm.mixin.injection.At; @@ -53,19 +55,19 @@ public void onMove(MoverType moverType, Vector3d movement, CallbackInfo ci) { ClientPlayerWrapper player = ClientPlayerWrapper.get(this); Parkourability parkourability = Parkourability.get(player); if (parkourability == null) return; - Vector3d enforcedPos = parkourability.getBehaviorEnforcer().getEnforcedPosition(); + Vec3Wrapper enforcedPos = parkourability.getBehaviorEnforcer().getEnforcedPosition(); if (enforcedPos != null) { ci.cancel(); - Vector3d dMove = enforcedPos.subtract(player.position()); + Vec3Wrapper dMove = enforcedPos.subtract(player.position()); setBoundingBox(getBoundingBox().move(dMove)); setLocationFromBoundingbox(); return; } if (moverType != MoverType.SELF) return; - Vector3d enforcedMovePos = parkourability.getBehaviorEnforcer().getEnforcedMovePoint(); + Vec3Wrapper enforcedMovePos = parkourability.getBehaviorEnforcer().getEnforcedMovePoint(); if (enforcedMovePos != null) { ci.cancel(); - Vector3d dMove = enforcedMovePos.subtract(player.position()); + Vec3Wrapper dMove = enforcedMovePos.subtract(player.position()); player.setDeltaMovement(dMove); super.move(moverType, dMove); } diff --git a/src/main/java/com/alrex/parcool/utilities/BufferUtil.java b/src/main/java/com/alrex/parcool/utilities/BufferUtil.java index 53bb5224..b8b47a3d 100644 --- a/src/main/java/com/alrex/parcool/utilities/BufferUtil.java +++ b/src/main/java/com/alrex/parcool/utilities/BufferUtil.java @@ -1,11 +1,12 @@ package com.alrex.parcool.utilities; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.util.math.vector.Vector3i; import java.nio.ByteBuffer; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; + public class BufferUtil { ByteBuffer buffer; @@ -35,7 +36,7 @@ public BufferUtil putVector3i(Vector3i vec) { return this; } - public BufferUtil putVector3d(Vector3d vec) { + public BufferUtil putVector3d(Vec3Wrapper vec) { buffer.putDouble(vec.x()).putDouble(vec.y()).putDouble(vec.z()); return this; } @@ -48,8 +49,8 @@ public static Vector3i getVector3i(ByteBuffer buffer) { return new Vector3i(buffer.getInt(), buffer.getInt(), buffer.getInt()); } - public static Vector3d getVector3d(ByteBuffer buffer) { - return new Vector3d(buffer.getDouble(), buffer.getDouble(), buffer.getDouble()); + public static Vec3Wrapper getVector3d(ByteBuffer buffer) { + return new Vec3Wrapper(buffer.getDouble(), buffer.getDouble(), buffer.getDouble()); } diff --git a/src/main/java/com/alrex/parcool/utilities/EntityUtil.java b/src/main/java/com/alrex/parcool/utilities/EntityUtil.java index aa786e04..42c89ef3 100644 --- a/src/main/java/com/alrex/parcool/utilities/EntityUtil.java +++ b/src/main/java/com/alrex/parcool/utilities/EntityUtil.java @@ -1,10 +1,10 @@ package com.alrex.parcool.utilities; import com.alrex.parcool.api.compatibility.EntityWrapper; -import net.minecraft.util.math.vector.Vector3d; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; public class EntityUtil { - public static void addVelocity(EntityWrapper entity, Vector3d vec) { + public static void addVelocity(EntityWrapper entity, Vec3Wrapper vec) { entity.addToDeltaMovement(vec); } } diff --git a/src/main/java/com/alrex/parcool/utilities/VectorUtil.java b/src/main/java/com/alrex/parcool/utilities/VectorUtil.java index 8cdfa033..2e5de1e0 100644 --- a/src/main/java/com/alrex/parcool/utilities/VectorUtil.java +++ b/src/main/java/com/alrex/parcool/utilities/VectorUtil.java @@ -1,21 +1,21 @@ package com.alrex.parcool.utilities; -import net.minecraft.util.math.vector.Vector3d; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; public class VectorUtil { - public static double toYawDegree(Vector3d vec) { + public static double toYawDegree(Vec3Wrapper vec) { return (Math.atan2(vec.z(), vec.x()) * 180.0 / Math.PI - 90); } - public static double toYawRadian(Vector3d vec) { + public static double toYawRadian(Vec3Wrapper vec) { return (Math.atan2(vec.z(), vec.x()) - Math.PI / 2.); } - public static double toPitchDegree(Vector3d vec) { + public static double toPitchDegree(Vec3Wrapper vec) { return -(Math.atan2(vec.y(), Math.sqrt(vec.x() * vec.x() + vec.z() * vec.z())) * 180.0 / Math.PI); } - public static Vector3d fromYawDegree(double degree) { - return new Vector3d(-Math.sin(Math.toRadians(degree)), 0, Math.cos(Math.toRadians(degree))); + public static Vec3Wrapper fromYawDegree(double degree) { + return new Vec3Wrapper(-Math.sin(Math.toRadians(degree)), 0, Math.cos(Math.toRadians(degree))); } } diff --git a/src/main/java/com/alrex/parcool/utilities/WorldUtil.java b/src/main/java/com/alrex/parcool/utilities/WorldUtil.java index 7f38fbf0..d1d17424 100644 --- a/src/main/java/com/alrex/parcool/utilities/WorldUtil.java +++ b/src/main/java/com/alrex/parcool/utilities/WorldUtil.java @@ -2,6 +2,7 @@ import com.alrex.parcool.api.compatibility.EntityWrapper; import com.alrex.parcool.api.compatibility.LivingEntityWrapper; +import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.action.impl.HangDown; import com.alrex.parcool.common.tags.BlockTags; import net.minecraft.block.*; @@ -10,18 +11,17 @@ import net.minecraft.util.Tuple; import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.vector.Vector3d; import net.minecraft.world.World; import javax.annotation.Nullable; public class WorldUtil { - public static Vector3d getRunnableWall(LivingEntityWrapper entity, double range) { + public static Vec3Wrapper getRunnableWall(LivingEntityWrapper entity, double range) { double width = entity.getBbWidth() * 0.4f; double wallX = 0; double wallZ = 0; - Vector3d pos = entity.position(); + Vec3Wrapper pos = entity.position(); AxisAlignedBB baseBox1 = new AxisAlignedBB( pos.x() - width, @@ -62,19 +62,19 @@ public static Vector3d getRunnableWall(LivingEntityWrapper entity, double range) } if (wallX == 0 && wallZ == 0) return null; - return new Vector3d(wallX, 0, wallZ); + return new Vec3Wrapper(wallX, 0, wallZ); } @Nullable - public static Vector3d getWall(LivingEntityWrapper entity) { + public static Vec3Wrapper getWall(LivingEntityWrapper entity) { return getWall(entity, entity.getBbWidth() * 0.5); } @Nullable - public static Vector3d getWall(LivingEntityWrapper entity, double range) { + public static Vec3Wrapper getWall(LivingEntityWrapper entity, double range) { final double width = entity.getBbWidth() * 0.49; double wallX = 0; double wallZ = 0; - Vector3d pos = entity.position(); + Vec3Wrapper pos = entity.position(); AxisAlignedBB baseBox = new AxisAlignedBB( pos.x() - width, @@ -99,18 +99,18 @@ public static Vector3d getWall(LivingEntityWrapper entity, double range) { } if (wallX == 0 && wallZ == 0) return null; - return new Vector3d(wallX, 0, wallZ); + return new Vec3Wrapper(wallX, 0, wallZ); } @Nullable - public static Vector3d getVaultableStep(LivingEntityWrapper entity) { + public static Vec3Wrapper getVaultableStep(LivingEntityWrapper entity) { final double d = entity.getBbWidth() * 0.5; World world = entity.getLevel(); double distance = entity.getBbWidth() / 2; double baseLine = Math.min(entity.getBbHeight() * 0.86, getWallHeight(entity)); double stepX = 0; double stepZ = 0; - Vector3d pos = entity.position(); + Vec3Wrapper pos = entity.position(); AxisAlignedBB baseBoxBottom = new AxisAlignedBB( pos.x() - d, @@ -142,7 +142,7 @@ public static Vector3d getVaultableStep(LivingEntityWrapper entity) { } if (stepX == 0 && stepZ == 0) return null; if (stepX == 0 || stepZ == 0) { - Vector3d result = new Vector3d(stepX, 0, stepZ); + Vec3Wrapper result = new Vec3Wrapper(stepX, 0, stepZ); BlockPos target = new BlockPos(entity.position().add(result).add(0, 0.5, 0)); if (!world.isLoaded(target)) return null; BlockState state = world.getBlockState(target); @@ -157,14 +157,14 @@ public static Vector3d getVaultableStep(LivingEntityWrapper entity) { } } - return new Vector3d(stepX, 0, stepZ); + return new Vec3Wrapper(stepX, 0, stepZ); } - public static double getWallHeight(LivingEntityWrapper entity, Vector3d direction, double maxHeight, double accuracy) { + public static double getWallHeight(LivingEntityWrapper entity, Vec3Wrapper direction, double maxHeight, double accuracy) { final double d = entity.getBbWidth() * 0.49; direction = direction.normalize(); World world = entity.getLevel(); - Vector3d pos = entity.position(); + Vec3Wrapper pos = entity.position(); boolean canReturn = false; for (double height = 0; height < maxHeight; height += accuracy) { AxisAlignedBB box = new AxisAlignedBB( @@ -187,13 +187,13 @@ public static double getWallHeight(LivingEntityWrapper entity, Vector3d directio } public static double getWallHeight(LivingEntityWrapper entity) { - Vector3d wall = getWall(entity); + Vec3Wrapper wall = getWall(entity); if (wall == null) return 0; World world = entity.getLevel(); final double accuracy = entity.getBbHeight() / 18; // normally about 0.1 final double d = entity.getBbWidth() * 0.5; int loopNum = (int) Math.round(entity.getBbHeight() / accuracy); - Vector3d pos = entity.position(); + Vec3Wrapper pos = entity.position(); boolean canReturn = false; for (int i = 0; i < loopNum; i++) { AxisAlignedBB box = new AxisAlignedBB( @@ -291,7 +291,7 @@ public static HangDown.BarAxis getHangableBars(LivingEntityWrapper entity) { public static boolean existsSpaceBelow(LivingEntityWrapper entity) { World world = entity.getLevel(); - Vector3d center = entity.position(); + Vec3Wrapper center = entity.position(); if (!world.isLoaded(new BlockPos(center))) return false; double height = entity.getBbHeight() * 1.5; double width = entity.getBbWidth() * 2; @@ -310,11 +310,11 @@ public static boolean existsDivableSpace(LivingEntityWrapper entity) { double width = entity.getBbWidth() * 1.5; double height = entity.getBbHeight() * 1.5; double wideWidth = entity.getBbWidth() * 2; - Vector3d center = entity.position(); + Vec3Wrapper center = entity.position(); if (!world.isLoaded(new BlockPos(center))) return false; - Vector3d diveDirection = VectorUtil.fromYawDegree(entity.getYHeadRot()); + Vec3Wrapper diveDirection = VectorUtil.fromYawDegree(entity.getYHeadRot()); for (int i = 0; i < 4; i++) { - Vector3d centerPoint = center.add(diveDirection.scale(width * i)); + Vec3Wrapper centerPoint = center.add(diveDirection.scale(width * i)); AxisAlignedBB box = new AxisAlignedBB( centerPoint.x() - width, centerPoint.y() + 0.05, @@ -371,21 +371,21 @@ public static boolean existsDivableSpace(LivingEntityWrapper entity) { } @Nullable - public static Vector3d getGrabbableWall(LivingEntityWrapper entity) { + public static Vec3Wrapper getGrabbableWall(LivingEntityWrapper entity) { final double d = entity.getBbWidth() * 0.5; World world = entity.getLevel(); double distance = entity.getBbWidth() / 2; double baseLine1 = entity.getEyeHeight() + (entity.getBbHeight() - entity.getEyeHeight()) / 2; double baseLine2 = entity.getBbHeight() + (entity.getBbHeight() - entity.getEyeHeight()) / 2; - Vector3d wall1 = getGrabbableWall(entity, distance, baseLine1); + Vec3Wrapper wall1 = getGrabbableWall(entity, distance, baseLine1); if (wall1 != null) return wall1; return getGrabbableWall(entity, distance, baseLine2); } - private static Vector3d getGrabbableWall(LivingEntityWrapper entity, double distance, double baseLine) { + private static Vec3Wrapper getGrabbableWall(LivingEntityWrapper entity, double distance, double baseLine) { final double d = entity.getBbWidth() * 0.49; World world = entity.getLevel(); - Vector3d pos = entity.position(); + Vec3Wrapper pos = entity.position(); AxisAlignedBB baseBoxSide = new AxisAlignedBB( pos.x() - d, pos.y() + baseLine - entity.getBbHeight() / 6, @@ -439,7 +439,7 @@ private static Vector3d getGrabbableWall(LivingEntityWrapper entity, double dist if (!entity.isEveryLoaded(blockPos)) return null; slipperiness = entity.getMinSlipperiness(blockPos); } - return slipperiness <= 0.9 ? new Vector3d(xDirection, 0, zDirection) : null; + return slipperiness <= 0.9 ? new Vec3Wrapper(xDirection, 0, zDirection) : null; } public static boolean isHideAbleBlock(BlockState blockState) { @@ -467,7 +467,7 @@ public static Tuple getHideAbleSpace(EntityWrapper entity, B double entityHeight = entity.getBbHeight(); if (entityHeight >= 2 || entityWidth >= 1) return null; if (entityHeight < 1) return new Tuple<>(base, base); - Vector3d lookAngle = entity.getLookAngle(); + Vec3Wrapper lookAngle = entity.getLookAngle(); if (Math.abs(lookAngle.z()) > Math.abs(lookAngle.x())) { if (lookAngle.z() > 0) { if (getHideAbleSpace$isHideAble(world, block, base.south())) return new Tuple<>(base, base.south()); From d98673b9fcce6b7ca790be9b6fee2913a397cb46 Mon Sep 17 00:00:00 2001 From: Thiago Santos Date: Thu, 1 May 2025 22:30:39 -0300 Subject: [PATCH 3/8] refactor: removing LazyOptional --- .../parcool/api/compatibility/EntityWrapper.java | 12 ++++++++---- .../api/compatibility/LivingEntityWrapper.java | 6 ------ .../parcool/api/compatibility/PlayerWrapper.java | 14 -------------- .../alrex/parcool/common/capability/Animation.java | 7 +++---- .../alrex/parcool/common/capability/IStamina.java | 5 +---- .../parcool/common/capability/Parkourability.java | 4 +--- 6 files changed, 13 insertions(+), 35 deletions(-) diff --git a/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java index 9ee1d2e1..12095636 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java +++ b/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java @@ -3,6 +3,7 @@ import java.util.UUID; import javax.annotation.Nonnull; +import javax.annotation.Nullable; import com.alrex.parcool.client.animation.PlayerModelRotator; import net.minecraft.block.BlockState; @@ -63,11 +64,14 @@ public float getBbWidth() { public BlockState getBlockState(BlockPos pos) { return entity.level.getBlockState(pos); } - - public LazyOptional getCapability(@Nonnull final Capability cap) { - return entity.getCapability(cap); + + @Nullable + public T getCapability(@Nonnull final Capability cap) { + LazyOptional optional = entity.getCapability(cap); + if (!optional.isPresent()) return null; + return optional.orElse(null); } - + public Vec3Wrapper getDeltaMovement() { return new Vec3Wrapper(entity.getDeltaMovement()); } diff --git a/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java index 45099175..b8f48850 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java +++ b/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java @@ -17,8 +17,6 @@ import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.common.ForgeMod; -import net.minecraftforge.common.capabilities.Capability; -import net.minecraftforge.common.util.LazyOptional; public class LivingEntityWrapper extends EntityWrapper { @@ -48,10 +46,6 @@ public AxisAlignedBB getBoundingBox() { return entity.getBoundingBox(); } - public LazyOptional getCapability(@Nonnull final Capability cap) { - return entity.getCapability(cap); - } - public double getGravity() { return entity.getAttributeValue(ForgeMod.ENTITY_GRAVITY.get()); } diff --git a/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java index d861ae2b..849abac0 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java +++ b/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java @@ -4,7 +4,6 @@ import java.util.function.Consumer; import java.util.function.Supplier; -import javax.annotation.Nonnull; import javax.annotation.Nullable; import com.alrex.parcool.utilities.VectorUtil; @@ -23,9 +22,7 @@ import net.minecraft.util.math.BlockPos; import net.minecraft.util.text.IFormattableTextComponent; import net.minecraft.world.World; -import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.common.capabilities.CapabilityProvider; -import net.minecraftforge.common.util.LazyOptional; import net.minecraftforge.event.AttachCapabilitiesEvent; import net.minecraftforge.event.TickEvent.PlayerTickEvent; import net.minecraftforge.event.entity.living.LivingEvent; @@ -90,10 +87,6 @@ public Object getVehicle() { return player.getVehicle(); } - public LazyOptional getCapability(@Nonnull final Capability cap) { - return player.getCapability(cap); - } - public Iterable getPlayersOnSameLevel() { return MinecraftServerWrapper.getPlayers(player.level.players()); } @@ -184,9 +177,6 @@ public static PlayerWrapper getFromEntityOrDefault(LivingEvent event) { } // All has/is boolean methods grouped - public boolean hasEffect(Effect effect) { - return player.hasEffect(effect); - } public boolean hasHurtTime() { return player.hurtTime > 0; @@ -338,10 +328,6 @@ public void multiplyFallDistance(float multiplier) { player.fallDistance *= multiplier; } - public void playSound(SoundEvent soundEvent, float i, float j) { - player.playSound(soundEvent, i, j); - } - public void rotateBodyRot0(Vec3Wrapper direction, double d) { player.yBodyRotO = player.yBodyRot = (float) VectorUtil.toYawDegree(direction.yRot((float) d)); } diff --git a/src/main/java/com/alrex/parcool/common/capability/Animation.java b/src/main/java/com/alrex/parcool/common/capability/Animation.java index 96c07c5e..4b61158e 100644 --- a/src/main/java/com/alrex/parcool/common/capability/Animation.java +++ b/src/main/java/com/alrex/parcool/common/capability/Animation.java @@ -17,15 +17,14 @@ import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.client.event.EntityViewRenderEvent; import net.minecraftforge.common.MinecraftForge; -import net.minecraftforge.common.util.LazyOptional; import net.minecraftforge.event.TickEvent; @OnlyIn(Dist.CLIENT) public class Animation { public static Animation get(PlayerWrapper player) { - LazyOptional optional = player.getCapability(Capabilities.ANIMATION_CAPABILITY); - if (!optional.isPresent()) return null; - return optional.orElseThrow(IllegalStateException::new); + Animation animation = player.getCapability(Capabilities.ANIMATION_CAPABILITY); + if (animation == null) throw new IllegalStateException(); + return animation; } private Animator animator = null; diff --git a/src/main/java/com/alrex/parcool/common/capability/IStamina.java b/src/main/java/com/alrex/parcool/common/capability/IStamina.java index 6c3e2ae0..49a58a7c 100644 --- a/src/main/java/com/alrex/parcool/common/capability/IStamina.java +++ b/src/main/java/com/alrex/parcool/common/capability/IStamina.java @@ -5,8 +5,6 @@ import com.alrex.parcool.common.capability.capabilities.Capabilities; import com.alrex.parcool.common.capability.stamina.HungerStamina; import com.alrex.parcool.common.capability.stamina.Stamina; -import net.minecraftforge.common.util.LazyOptional; - import javax.annotation.Nullable; import java.util.function.BiConsumer; import java.util.function.Function; @@ -48,8 +46,7 @@ public static Type getFromInstance(IStamina stamina) { } @Nullable public static IStamina get(PlayerWrapper player) { - LazyOptional optional = player.getCapability(Capabilities.STAMINA_CAPABILITY); - return optional.orElse(null); + return player.getCapability(Capabilities.STAMINA_CAPABILITY); } public int getActualMaxStamina(); diff --git a/src/main/java/com/alrex/parcool/common/capability/Parkourability.java b/src/main/java/com/alrex/parcool/common/capability/Parkourability.java index 1ab1bfdc..9a59532e 100644 --- a/src/main/java/com/alrex/parcool/common/capability/Parkourability.java +++ b/src/main/java/com/alrex/parcool/common/capability/Parkourability.java @@ -13,7 +13,6 @@ import com.alrex.parcool.common.network.SyncClientInformationMessage; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; -import net.minecraftforge.common.util.LazyOptional; import javax.annotation.Nullable; import java.util.HashMap; @@ -22,8 +21,7 @@ public class Parkourability { @Nullable public static Parkourability get(PlayerWrapper player) { - LazyOptional optional = player.getCapability(Capabilities.PARKOURABILITY_CAPABILITY); - return optional.orElse(null); + return player.getCapability(Capabilities.PARKOURABILITY_CAPABILITY); } private final ActionInfo info; From 9dcff20653cd1ea0a67630cca569a19f45ff423b Mon Sep 17 00:00:00 2001 From: Thiago Santos Date: Fri, 2 May 2025 00:11:22 -0300 Subject: [PATCH 4/8] refactor: adding LevelWrapper --- .../api/compatibility/EntityWrapper.java | 5 +- .../api/compatibility/LevelWrapper.java | 72 +++++++++++++++++++ .../compatibility/LivingEntityWrapper.java | 5 +- .../api/compatibility/PlayerWrapper.java | 5 +- .../animation/PassiveCustomAnimation.java | 4 +- .../parcool/common/action/impl/CatLeap.java | 4 +- .../common/action/impl/HideInBlock.java | 4 +- .../common/action/impl/HorizontalWallRun.java | 4 +- .../parcool/common/action/impl/Slide.java | 4 +- .../common/action/impl/VerticalWallRun.java | 4 +- .../parcool/common/action/impl/WallJump.java | 4 +- .../parcool/common/action/impl/WallSlide.java | 4 +- .../block/zipline/ZiplineHookBlock.java | 9 ++- .../block/zipline/ZiplineHookTileEntity.java | 4 +- .../network/SyncActionStateMessage.java | 5 +- .../common/network/SyncStaminaMessage.java | 5 +- .../alrex/parcool/common/zipline/Zipline.java | 9 +-- .../mixin/common/LivingEntityMixin.java | 17 ++--- .../alrex/parcool/utilities/WorldUtil.java | 24 +++---- 19 files changed, 132 insertions(+), 60 deletions(-) create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/LevelWrapper.java diff --git a/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java index 12095636..023997e2 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java +++ b/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java @@ -13,7 +13,6 @@ import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.MathHelper; -import net.minecraft.world.World; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.common.util.LazyOptional; @@ -84,8 +83,8 @@ public float getFallDistance() { return entity.fallDistance; } - public World getLevel() { - return entity.level; + public LevelWrapper getLevel() { + return LevelWrapper.get(entity.level); } public Vec3Wrapper getLookAngle() { diff --git a/src/main/java/com/alrex/parcool/api/compatibility/LevelWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/LevelWrapper.java new file mode 100644 index 00000000..65d59193 --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/LevelWrapper.java @@ -0,0 +1,72 @@ +package com.alrex.parcool.api.compatibility; + +import java.util.List; +import java.util.UUID; + +import com.alrex.parcool.common.entity.zipline.ZiplineRopeEntity; + +import net.minecraft.block.BlockState; +import net.minecraft.client.Minecraft; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.particles.BasicParticleType; +import net.minecraft.particles.BlockParticleData; +import net.minecraft.particles.IParticleData; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.math.AxisAlignedBB; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +public final class LevelWrapper { + private World level; + private static final WeakCache cache = new WeakCache<>(); + private static final Minecraft mc = Minecraft.getInstance(); + + public LevelWrapper(World level) { + this.level = level; + } + + public static LevelWrapper get(World level) { + return cache.get(level, () -> new LevelWrapper(level)); + } + + public PlayerEntity getPlayerByUUID(UUID playerID) { + return level.getPlayerByUUID(playerID); + } + + public void addParticle(IParticleData drippingWater, double d, double e, double f, double x, double g, + double z) { + level.addParticle(drippingWater, d, e, f, x, g, z); + } + + public boolean isLoaded(BlockPos blockpos) { + return level.isLoaded(blockpos); + } + + public BlockState getBlockState(BlockPos blockpos) { + return level.getBlockState(blockpos); + } + + public boolean isClientSide() { + return level.isClientSide(); + } + + public TileEntity getBlockEntity(BlockPos pos) { + return level.getBlockEntity(pos); + } + + public static LevelWrapper get() { + return get(mc.level); + } + + public boolean isCollisionShapeFullBlock(BlockState state, BlockPos pos) { + return state.isCollisionShapeFullBlock(level, pos); + } + + public boolean noCollision(AxisAlignedBB expandTowards) { + return level.noCollision(expandTowards); + } + + public List getEntitiesOfClass(Class class1, AxisAlignedBB inflate) { + return level.getEntitiesOfClass(class1, inflate); + } +} diff --git a/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java index b8f48850..29c4a6d8 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java +++ b/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java @@ -15,7 +15,6 @@ import net.minecraft.util.Hand; import net.minecraft.util.HandSide; import net.minecraft.util.math.AxisAlignedBB; -import net.minecraft.util.math.vector.Vector3d; import net.minecraftforge.common.ForgeMod; public class LivingEntityWrapper extends EntityWrapper { @@ -63,8 +62,8 @@ public Vec3Wrapper getRotatedBodyAngle(PlayerModelRotator rotator) { } public double getUpdatedYRotDifference() { - Vector3d currentAngle = VectorUtil.fromYawDegree(entity.yBodyRot); - Vector3d oldAngle = VectorUtil.fromYawDegree(entity.yBodyRotO); + Vec3Wrapper currentAngle = VectorUtil.fromYawDegree(entity.yBodyRot); + Vec3Wrapper oldAngle = VectorUtil.fromYawDegree(entity.yBodyRotO); return Math.atan( (oldAngle.x() * currentAngle.z() - currentAngle.x() * oldAngle.z()) / (currentAngle.x() * oldAngle.x() + currentAngle.z() * oldAngle.z()) diff --git a/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java index 849abac0..6e077f0a 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java +++ b/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java @@ -15,13 +15,10 @@ import net.minecraft.entity.player.PlayerEntity; import net.minecraft.item.ItemStack; import net.minecraft.item.ItemUseContext; -import net.minecraft.potion.Effect; import net.minecraft.util.DamageSource; import net.minecraft.util.Hand; -import net.minecraft.util.SoundEvent; import net.minecraft.util.math.BlockPos; import net.minecraft.util.text.IFormattableTextComponent; -import net.minecraft.world.World; import net.minecraftforge.common.capabilities.CapabilityProvider; import net.minecraftforge.event.AttachCapabilitiesEvent; import net.minecraftforge.event.TickEvent.PlayerTickEvent; @@ -133,7 +130,7 @@ public static PlayerWrapper get(Supplier contextSupplier) { } @Nullable - public static PlayerWrapper get(World world, UUID playerID) { + public static PlayerWrapper get(LevelWrapper world, UUID playerID) { PlayerEntity playerEntity = world.getPlayerByUUID(playerID); if (playerEntity == null) return null; return PlayerWrapper.get(playerEntity); diff --git a/src/main/java/com/alrex/parcool/client/animation/PassiveCustomAnimation.java b/src/main/java/com/alrex/parcool/client/animation/PassiveCustomAnimation.java index 0baf2f1a..9bb520e7 100644 --- a/src/main/java/com/alrex/parcool/client/animation/PassiveCustomAnimation.java +++ b/src/main/java/com/alrex/parcool/client/animation/PassiveCustomAnimation.java @@ -1,5 +1,6 @@ package com.alrex.parcool.client.animation; +import com.alrex.parcool.api.compatibility.LevelWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.input.KeyBindings; @@ -11,7 +12,6 @@ import com.alrex.parcool.utilities.MathUtil; import com.alrex.parcool.utilities.VectorUtil; import net.minecraft.particles.ParticleTypes; -import net.minecraft.world.World; import java.util.Random; @@ -108,7 +108,7 @@ private void rotateCreativeFlying(PlayerWrapper player, PlayerModelRotator rotat } private void spawnSweatParticle(PlayerWrapper player) { - World level = player.getLevel(); + LevelWrapper level = player.getLevel(); Random rand = player.getRandom(); Vec3Wrapper particleSpeed = player.getDeltaMovement().scale(0.6); level.addParticle( diff --git a/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java b/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java index b2c83a6c..5dd5df13 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java @@ -2,6 +2,7 @@ import com.alrex.parcool.api.SoundEvents; import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.api.compatibility.LevelWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.CatLeapAnimator; @@ -17,7 +18,6 @@ import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; -import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -123,7 +123,7 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { @OnlyIn(Dist.CLIENT) private void spawnJumpEffect(PlayerWrapper player, Vec3Wrapper jumpDirection) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; - World level = player.getLevel(); + LevelWrapper level = player.getLevel(); Vec3Wrapper pos = player.position(); BlockPos blockpos = new BlockPos(pos.add(0, -0.2, 0)); if (!level.isLoaded(blockpos)) return; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java b/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java index 706ac38b..15e2955b 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java @@ -1,5 +1,6 @@ package com.alrex.parcool.common.action.impl; +import com.alrex.parcool.api.compatibility.LevelWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.RenderBehaviorEnforcer; @@ -20,7 +21,6 @@ import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.BlockRayTraceResult; import net.minecraft.util.math.RayTraceResult; -import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -216,7 +216,7 @@ public void onStop(PlayerWrapper player) { @OnlyIn(Dist.CLIENT) private void spawnOnHideParticles(PlayerWrapper player) { if (hidingArea == null) return; - World world = player.getLevel(); + LevelWrapper world = player.getLevel(); int minX = hidingArea.getA().getX(); int minY = hidingArea.getA().getY(); int minZ = hidingArea.getA().getZ(); diff --git a/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java b/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java index 74ffb924..e4ceb79d 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.LevelWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.HorizontalWallRunAnimator; @@ -22,7 +23,6 @@ import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; -import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.event.TickEvent; @@ -232,7 +232,7 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { public void spawnRunningParticle(PlayerWrapper player) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; if (runningDirection == null || runningWallDirection == null) return; - World level = player.getLevel(); + LevelWrapper level = player.getLevel(); Vec3Wrapper pos = player.position(); BlockPos leanedBlock = new BlockPos( pos.add(runningWallDirection.x(), player.getBbHeight() * 0.25, runningWallDirection.z()) diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Slide.java b/src/main/java/com/alrex/parcool/common/action/impl/Slide.java index b38b2066..f05533b8 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Slide.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Slide.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.LevelWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.CrawlAnimator; @@ -20,7 +21,6 @@ import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; -import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -126,7 +126,7 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { @OnlyIn(Dist.CLIENT) private void spawnSlidingParticle(PlayerWrapper player) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; - World level = player.getLevel(); + LevelWrapper level = player.getLevel(); Vec3Wrapper pos = player.position(); BlockState feetBlock = player.getBelowBlockState(); float width = player.getBbWidth(); diff --git a/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java b/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java index 727bcaf1..716d1d96 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.LevelWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.VerticalWallRunAnimator; @@ -18,7 +19,6 @@ import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; -import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.event.TickEvent; @@ -138,7 +138,7 @@ public StaminaConsumeTiming getStaminaConsumeTiming() { public void spawnRunningParticle(PlayerWrapper player) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; if (wallDirection == null) return; - World level = player.getLevel(); + LevelWrapper level = player.getLevel(); Vec3Wrapper pos = player.position(); BlockPos leanedBlock = new BlockPos( pos.add(wallDirection.x(), player.getBbHeight() * 0.25, wallDirection.z()) diff --git a/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java b/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java index 312154ca..3d1eae1c 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.LevelWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.BackwardWallJumpAnimator; @@ -18,7 +19,6 @@ import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; -import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -239,7 +239,7 @@ public void onWorkingTickInClient(PlayerWrapper player, Parkourability parkourab @OnlyIn(Dist.CLIENT) private void spawnJumpParticles(PlayerWrapper player, Vec3Wrapper wallDirection, Vec3Wrapper jumpDirection) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; - World level = player.getLevel(); + LevelWrapper level = player.getLevel(); Vec3Wrapper pos = player.position(); BlockPos leanedBlock = new BlockPos( pos.add(wallDirection.x(), player.getBbHeight() * 0.25, wallDirection.z()) diff --git a/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java b/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java index e08e2927..66b6dfb8 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java @@ -1,5 +1,6 @@ package com.alrex.parcool.common.action.impl; +import com.alrex.parcool.api.compatibility.LevelWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.WallSlideAnimator; @@ -17,7 +18,6 @@ import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; -import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -124,7 +124,7 @@ private void spawnSlideParticle(PlayerWrapper player) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; if (leanedWallDirection == null) return; if (player.getRandom().nextBoolean()) return; - World level = player.getLevel(); + LevelWrapper level = player.getLevel(); Vec3Wrapper pos = player.position(); BlockPos leanedBlock = new BlockPos( pos.add(leanedWallDirection.x(), player.getBbHeight() * 0.25, leanedWallDirection.z()) diff --git a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java index ec9078c2..0f13cfde 100644 --- a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java +++ b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.block.zipline; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.LevelWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.block.TileEntities; @@ -60,8 +61,9 @@ public BlockState getStateForPlacement(BlockItemUseContext context) { @Override public void onRemove(@Nonnull BlockState state, @Nonnull World world, @Nonnull BlockPos pos, @Nonnull BlockState p_196243_4_, boolean p_196243_5_) { - if (!world.isClientSide()) { - TileEntity tileEntity = world.getBlockEntity(pos); + LevelWrapper level = LevelWrapper.get(world); + if (!level.isClientSide()) { + TileEntity tileEntity = level.getBlockEntity(pos); if (tileEntity instanceof ZiplineHookTileEntity) { ZiplineHookTileEntity ziplineHookTileEntity = (ZiplineHookTileEntity) tileEntity; List itemStacks = ziplineHookTileEntity.removeAllConnection(); @@ -91,10 +93,11 @@ public boolean isPathfindable(BlockState p_196266_1_, IBlockReader p_196266_2_, @Override public ActionResultType use(BlockState blockState, World world, BlockPos pos, PlayerEntity playerEntity, Hand hand, BlockRayTraceResult blockRayTraceResult) { + LevelWrapper level = LevelWrapper.get(world); PlayerWrapper player = PlayerWrapper.get(playerEntity); ItemStack stack = player.getItemInHand(hand); if (stack.getItem() instanceof ShearsItem) { - TileEntity tileEntity = world.getBlockEntity(pos); + TileEntity tileEntity = level.getBlockEntity(pos); if (tileEntity instanceof ZiplineHookTileEntity) { ZiplineHookTileEntity ziplineHookTileEntity = (ZiplineHookTileEntity) tileEntity; if (ziplineHookTileEntity.getConnectionPoints().isEmpty()) return ActionResultType.PASS; diff --git a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookTileEntity.java b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookTileEntity.java index 714a878b..839a9b76 100644 --- a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookTileEntity.java +++ b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookTileEntity.java @@ -1,5 +1,6 @@ package com.alrex.parcool.common.block.zipline; +import com.alrex.parcool.api.compatibility.LevelWrapper; import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.entity.zipline.ZiplineRopeEntity; import com.alrex.parcool.common.item.Items; @@ -116,7 +117,8 @@ public boolean connectTo(ZiplineHookTileEntity target, ZiplineInfo info) { @Nullable private ZiplineRopeEntity spawnRope(World level, ZiplineHookTileEntity target, ZiplineInfo info) { - if (level.isClientSide()) return null; + LevelWrapper levelWrapper = LevelWrapper.get(level); + if (levelWrapper.isClientSide()) return null; if (target.connectionEntities.containsKey(this.getBlockPos())) return null; ZiplineRopeEntity entity = new ZiplineRopeEntity(level, getBlockPos(), target.getBlockPos(), info); diff --git a/src/main/java/com/alrex/parcool/common/network/SyncActionStateMessage.java b/src/main/java/com/alrex/parcool/common/network/SyncActionStateMessage.java index eb1cacbf..21e8e14b 100644 --- a/src/main/java/com/alrex/parcool/common/network/SyncActionStateMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/SyncActionStateMessage.java @@ -2,12 +2,11 @@ import com.alrex.parcool.ParCool; import com.alrex.parcool.api.compatibility.EventBusWrapper; +import com.alrex.parcool.api.compatibility.LevelWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.capability.Parkourability; -import net.minecraft.client.Minecraft; import net.minecraft.network.PacketBuffer; -import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.fml.LogicalSide; @@ -87,7 +86,7 @@ public void handleClient(Supplier contextSupplier) { PlayerWrapper player; boolean clientSide; if (contextSupplier.get().getDirection().getReceptionSide() == LogicalSide.CLIENT) { - World world = Minecraft.getInstance().level; + LevelWrapper world = LevelWrapper.get(); if (world == null) return; player = PlayerWrapper.get(world, senderUUID); if (player == null || player.isLocalPlayer()) return; diff --git a/src/main/java/com/alrex/parcool/common/network/SyncStaminaMessage.java b/src/main/java/com/alrex/parcool/common/network/SyncStaminaMessage.java index 4692aa8b..f891df48 100644 --- a/src/main/java/com/alrex/parcool/common/network/SyncStaminaMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/SyncStaminaMessage.java @@ -1,13 +1,12 @@ package com.alrex.parcool.common.network; import com.alrex.parcool.ParCool; +import com.alrex.parcool.api.compatibility.LevelWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.stamina.OtherStamina; -import net.minecraft.client.Minecraft; import net.minecraft.network.PacketBuffer; -import net.minecraft.world.World; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.fml.LogicalSide; @@ -74,7 +73,7 @@ public void handleClient(Supplier contextSupplier) { ServerPlayerWrapper serverPlayer = null; PlayerWrapper player; if (contextSupplier.get().getDirection().getReceptionSide() == LogicalSide.CLIENT) { - World world = Minecraft.getInstance().level; + LevelWrapper world = LevelWrapper.get(); if (world == null) return; player = PlayerWrapper.get(world, playerID); if (player == null || player.isLocalPlayer()) return; diff --git a/src/main/java/com/alrex/parcool/common/zipline/Zipline.java b/src/main/java/com/alrex/parcool/common/zipline/Zipline.java index 566ddf8c..0cfc3734 100644 --- a/src/main/java/com/alrex/parcool/common/zipline/Zipline.java +++ b/src/main/java/com/alrex/parcool/common/zipline/Zipline.java @@ -1,5 +1,6 @@ package com.alrex.parcool.common.zipline; +import com.alrex.parcool.api.compatibility.LevelWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.entity.zipline.ZiplineRopeEntity; @@ -47,13 +48,13 @@ public double getHorizontalDistance() { } @Nullable - public static ZiplineRopeEntity getHangableZipline(World world, PlayerWrapper player) { - return getHangableZipline(world, player, null); + public static ZiplineRopeEntity getHangableZipline(LevelWrapper level, PlayerWrapper player) { + return getHangableZipline(level, player, null); } @Nullable - public static ZiplineRopeEntity getHangableZipline(World world, PlayerWrapper player, @Nullable ZiplineRopeEntity except) { - List entities = world.getEntitiesOfClass( + public static ZiplineRopeEntity getHangableZipline(LevelWrapper level, PlayerWrapper player, @Nullable ZiplineRopeEntity except) { + List entities = level.getEntitiesOfClass( ZiplineRopeEntity.class, player.getBoundingBox().inflate(MAXIMUM_DISTANCE * 0.52) ); diff --git a/src/main/java/com/alrex/parcool/mixin/common/LivingEntityMixin.java b/src/main/java/com/alrex/parcool/mixin/common/LivingEntityMixin.java index f2d6a0bf..23330b3c 100644 --- a/src/main/java/com/alrex/parcool/mixin/common/LivingEntityMixin.java +++ b/src/main/java/com/alrex/parcool/mixin/common/LivingEntityMixin.java @@ -1,6 +1,7 @@ package com.alrex.parcool.mixin.common; import com.alrex.parcool.api.compatibility.EventBusWrapper; +import com.alrex.parcool.api.compatibility.LevelWrapper; import com.alrex.parcool.api.compatibility.LivingEntityWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.impl.ChargeJump; @@ -76,7 +77,7 @@ public void onClimbable(CallbackInfoReturnable cir) { } @Unique - public boolean parCool$isLivingOnCustomLadder(@Nonnull BlockState state, @Nonnull World world, @Nonnull BlockPos pos, @Nonnull LivingEntityWrapper entity) { + public boolean parCool$isLivingOnCustomLadder(@Nonnull BlockState state, @Nonnull LevelWrapper world, @Nonnull BlockPos pos, @Nonnull LivingEntityWrapper entity) { boolean isSpectator = PlayerWrapper.is(entity) && entity.isSpectator(); if (isSpectator) return false; if (!ForgeConfig.SERVER.fullBoundingBoxLadders.get()) { @@ -105,7 +106,7 @@ public void onClimbable(CallbackInfoReturnable cir) { } @Unique - private boolean parCool$isCustomLadder(BlockState state, World world, BlockPos pos, LivingEntityWrapper entity) { + private boolean parCool$isCustomLadder(BlockState state, LevelWrapper level, BlockPos pos, LivingEntityWrapper entity) { Block block = state.getBlockState().getBlock(); if (block instanceof FourWayBlock) { int zCount = 0; @@ -114,19 +115,19 @@ public void onClimbable(CallbackInfoReturnable cir) { if (state.getValue(FourWayBlock.SOUTH)) zCount++; if (state.getValue(FourWayBlock.EAST)) xCount++; if (state.getValue(FourWayBlock.WEST)) xCount++; - boolean stacked = world.isLoaded(pos.above()) && world.getBlockState(pos.above()).getBlock() instanceof FourWayBlock; - if (!stacked && world.isLoaded(pos.below()) && world.getBlockState(pos.below()).getBlock() instanceof FourWayBlock) + boolean stacked = level.isLoaded(pos.above()) && level.getBlockState(pos.above()).getBlock() instanceof FourWayBlock; + if (!stacked && level.isLoaded(pos.below()) && level.getBlockState(pos.below()).getBlock() instanceof FourWayBlock) stacked = true; return ((zCount + xCount <= 1) || (zCount == 1 && xCount == 1)) && stacked; } else if (block instanceof RotatedPillarBlock) { - boolean stacked = world.isLoaded(pos.above()) && world.getBlockState(pos.above()).getBlock() instanceof RotatedPillarBlock; - if (!stacked && world.isLoaded(pos.below()) && world.getBlockState(pos.below()).getBlock() instanceof RotatedPillarBlock) + boolean stacked = level.isLoaded(pos.above()) && level.getBlockState(pos.above()).getBlock() instanceof RotatedPillarBlock; + if (!stacked && level.isLoaded(pos.below()) && level.getBlockState(pos.below()).getBlock() instanceof RotatedPillarBlock) stacked = true; - return !state.isCollisionShapeFullBlock(world, pos) && state.getValue(RotatedPillarBlock.AXIS).isVertical(); + return !level.isCollisionShapeFullBlock(state, pos) && state.getValue(RotatedPillarBlock.AXIS).isVertical(); } else if (block instanceof DirectionalBlock) { Direction direction = state.getValue(DirectionalBlock.FACING); - return !state.isCollisionShapeFullBlock(world, pos) && (direction == Direction.UP || direction == Direction.DOWN); + return !level.isCollisionShapeFullBlock(state, pos) && (direction == Direction.UP || direction == Direction.DOWN); } return false; } diff --git a/src/main/java/com/alrex/parcool/utilities/WorldUtil.java b/src/main/java/com/alrex/parcool/utilities/WorldUtil.java index d1d17424..e4e61656 100644 --- a/src/main/java/com/alrex/parcool/utilities/WorldUtil.java +++ b/src/main/java/com/alrex/parcool/utilities/WorldUtil.java @@ -1,6 +1,7 @@ package com.alrex.parcool.utilities; import com.alrex.parcool.api.compatibility.EntityWrapper; +import com.alrex.parcool.api.compatibility.LevelWrapper; import com.alrex.parcool.api.compatibility.LivingEntityWrapper; import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.action.impl.HangDown; @@ -11,7 +12,6 @@ import net.minecraft.util.Tuple; import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; -import net.minecraft.world.World; import javax.annotation.Nullable; @@ -105,7 +105,7 @@ public static Vec3Wrapper getWall(LivingEntityWrapper entity, double range) { @Nullable public static Vec3Wrapper getVaultableStep(LivingEntityWrapper entity) { final double d = entity.getBbWidth() * 0.5; - World world = entity.getLevel(); + LevelWrapper world = entity.getLevel(); double distance = entity.getBbWidth() / 2; double baseLine = Math.min(entity.getBbHeight() * 0.86, getWallHeight(entity)); double stepX = 0; @@ -163,7 +163,7 @@ public static Vec3Wrapper getVaultableStep(LivingEntityWrapper entity) { public static double getWallHeight(LivingEntityWrapper entity, Vec3Wrapper direction, double maxHeight, double accuracy) { final double d = entity.getBbWidth() * 0.49; direction = direction.normalize(); - World world = entity.getLevel(); + LevelWrapper world = entity.getLevel(); Vec3Wrapper pos = entity.position(); boolean canReturn = false; for (double height = 0; height < maxHeight; height += accuracy) { @@ -189,7 +189,7 @@ public static double getWallHeight(LivingEntityWrapper entity, Vec3Wrapper direc public static double getWallHeight(LivingEntityWrapper entity) { Vec3Wrapper wall = getWall(entity); if (wall == null) return 0; - World world = entity.getLevel(); + LevelWrapper world = entity.getLevel(); final double accuracy = entity.getBbHeight() / 18; // normally about 0.1 final double d = entity.getBbWidth() * 0.5; int loopNum = (int) Math.round(entity.getBbHeight() / accuracy); @@ -240,7 +240,7 @@ public static HangDown.BarAxis getHangableBars(LivingEntityWrapper entity) { Block block = state.getBlock(); HangDown.BarAxis axis = null; if (block instanceof RotatedPillarBlock) { - if (state.isCollisionShapeFullBlock(entity.getLevel(), pos)) { + if (entity.getLevel().isCollisionShapeFullBlock(state, pos)) { return null; } Direction.Axis pillarAxis = state.getValue(RotatedPillarBlock.AXIS); @@ -253,7 +253,7 @@ public static HangDown.BarAxis getHangableBars(LivingEntityWrapper entity) { break; } } else if (block instanceof DirectionalBlock) { - if (state.isCollisionShapeFullBlock(entity.getLevel(), pos)) { + if (entity.getLevel().isCollisionShapeFullBlock(state, pos)) { return null; } Direction direction = state.getValue(DirectionalBlock.FACING); @@ -290,7 +290,7 @@ public static HangDown.BarAxis getHangableBars(LivingEntityWrapper entity) { } public static boolean existsSpaceBelow(LivingEntityWrapper entity) { - World world = entity.getLevel(); + LevelWrapper world = entity.getLevel(); Vec3Wrapper center = entity.position(); if (!world.isLoaded(new BlockPos(center))) return false; double height = entity.getBbHeight() * 1.5; @@ -306,7 +306,7 @@ public static boolean existsSpaceBelow(LivingEntityWrapper entity) { return world.noCollision(boundingBox); } public static boolean existsDivableSpace(LivingEntityWrapper entity) { - World world = entity.getLevel(); + LevelWrapper world = entity.getLevel(); double width = entity.getBbWidth() * 1.5; double height = entity.getBbHeight() * 1.5; double wideWidth = entity.getBbWidth() * 2; @@ -373,7 +373,7 @@ public static boolean existsDivableSpace(LivingEntityWrapper entity) { @Nullable public static Vec3Wrapper getGrabbableWall(LivingEntityWrapper entity) { final double d = entity.getBbWidth() * 0.5; - World world = entity.getLevel(); + LevelWrapper world = entity.getLevel(); double distance = entity.getBbWidth() / 2; double baseLine1 = entity.getEyeHeight() + (entity.getBbHeight() - entity.getEyeHeight()) / 2; double baseLine2 = entity.getBbHeight() + (entity.getBbHeight() - entity.getEyeHeight()) / 2; @@ -384,7 +384,7 @@ public static Vec3Wrapper getGrabbableWall(LivingEntityWrapper entity) { private static Vec3Wrapper getGrabbableWall(LivingEntityWrapper entity, double distance, double baseLine) { final double d = entity.getBbWidth() * 0.49; - World world = entity.getLevel(); + LevelWrapper world = entity.getLevel(); Vec3Wrapper pos = entity.position(); AxisAlignedBB baseBoxSide = new AxisAlignedBB( pos.x() - d, @@ -446,13 +446,13 @@ public static boolean isHideAbleBlock(BlockState blockState) { return blockState.getBlock().getTags().contains(BlockTags.HIDE_ABLE); } - private static boolean getHideAbleSpace$isHideAble(World world, Block block, BlockPos pos) { + private static boolean getHideAbleSpace$isHideAble(LevelWrapper world, Block block, BlockPos pos) { return world.isLoaded(pos) && world.getBlockState(pos).is(block) && world.getBlockState(pos.above()).isAir(); } @Nullable public static Tuple getHideAbleSpace(EntityWrapper entity, BlockPos base) { - World world = entity.getLevel(); + LevelWrapper world = entity.getLevel(); if (!world.isLoaded(base)) return null; BlockState state = world.getBlockState(base); Block block = state.getBlock(); From e4ca62de9ee9361a7060d954895df2d6f640e8c4 Mon Sep 17 00:00:00 2001 From: Thiago Santos Date: Fri, 2 May 2025 08:56:35 -0300 Subject: [PATCH 5/8] refactor: adding BlockEntity, Containers and InteractionResult wrappers --- src/main/java/com/alrex/parcool/ParCool.java | 4 +-- .../api/compatibility/BlockEntityWrapper.java | 16 +++++++++ .../api/compatibility/ContainersWrapper.java | 15 ++++++++ .../InteractionResultWrapper.java | 10 ++++++ .../api/compatibility/LevelWrapper.java | 11 +++--- .../parcool/client/renderer/Renderers.java | 4 +-- .../block/zipline/ZiplineHookBlock.java | 36 +++++++++---------- ...EntityType.java => ParcoolEntityType.java} | 7 ++-- .../entity/zipline/ZiplineRopeEntity.java | 2 +- 9 files changed, 73 insertions(+), 32 deletions(-) create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/BlockEntityWrapper.java create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/ContainersWrapper.java create mode 100644 src/main/java/com/alrex/parcool/api/compatibility/InteractionResultWrapper.java rename src/main/java/com/alrex/parcool/common/entity/{EntityType.java => ParcoolEntityType.java} (75%) diff --git a/src/main/java/com/alrex/parcool/ParCool.java b/src/main/java/com/alrex/parcool/ParCool.java index 9ba482ed..b923d6a9 100644 --- a/src/main/java/com/alrex/parcool/ParCool.java +++ b/src/main/java/com/alrex/parcool/ParCool.java @@ -8,7 +8,7 @@ import com.alrex.parcool.common.block.Blocks; import com.alrex.parcool.common.block.TileEntities; import com.alrex.parcool.common.capability.capabilities.Capabilities; -import com.alrex.parcool.common.entity.EntityType; +import com.alrex.parcool.common.entity.ParcoolEntityType; import com.alrex.parcool.common.handlers.AddAttributesHandler; import com.alrex.parcool.common.item.Items; import com.alrex.parcool.common.item.recipe.Recipes; @@ -83,7 +83,7 @@ public ParCool() { Blocks.register(FMLJavaModLoadingContext.get().getModEventBus()); Items.register(FMLJavaModLoadingContext.get().getModEventBus()); Recipes.register(FMLJavaModLoadingContext.get().getModEventBus()); - EntityType.register(FMLJavaModLoadingContext.get().getModEventBus()); + ParcoolEntityType.register(FMLJavaModLoadingContext.get().getModEventBus()); TileEntities.register(FMLJavaModLoadingContext.get().getModEventBus()); ModLoadingContext.get().registerConfig(ModConfig.Type.SERVER, ParCoolConfig.Server.BUILT_CONFIG); diff --git a/src/main/java/com/alrex/parcool/api/compatibility/BlockEntityWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/BlockEntityWrapper.java new file mode 100644 index 00000000..250a6bac --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/BlockEntityWrapper.java @@ -0,0 +1,16 @@ +package com.alrex.parcool.api.compatibility; + +import net.minecraft.tileentity.TileEntity; + +public class BlockEntityWrapper { + private TileEntity blockEntity; + + public BlockEntityWrapper(TileEntity blockEntity) { + this.blockEntity = blockEntity; + } + + @SuppressWarnings("unchecked") + public T cast(Class classTarget) { + return classTarget.isInstance(blockEntity) ? (T) blockEntity : null; + } +} diff --git a/src/main/java/com/alrex/parcool/api/compatibility/ContainersWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/ContainersWrapper.java new file mode 100644 index 00000000..d4a3197e --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/ContainersWrapper.java @@ -0,0 +1,15 @@ +package com.alrex.parcool.api.compatibility; + +import net.minecraft.inventory.InventoryHelper; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; + +public class ContainersWrapper { + public static void dropItemStack(LevelWrapper level, double x, double y, double z, ItemStack stack) { + InventoryHelper.dropItemStack(level.getInstance(), x,y, z, stack); + } + + public static void dropItemStack(World level, double x, double y, double z, ItemStack stack) { + InventoryHelper.dropItemStack(level, x, y, z, stack); + } +} diff --git a/src/main/java/com/alrex/parcool/api/compatibility/InteractionResultWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/InteractionResultWrapper.java new file mode 100644 index 00000000..c13e1656 --- /dev/null +++ b/src/main/java/com/alrex/parcool/api/compatibility/InteractionResultWrapper.java @@ -0,0 +1,10 @@ +package com.alrex.parcool.api.compatibility; + +import net.minecraft.util.ActionResultType; + +public class InteractionResultWrapper { + public static final ActionResultType PASS = ActionResultType.PASS; + public static final ActionResultType CONSUME = ActionResultType.CONSUME; + public static final ActionResultType FAIL = ActionResultType.FAIL; + public static final ActionResultType SUCCESS = ActionResultType.SUCCESS; +} diff --git a/src/main/java/com/alrex/parcool/api/compatibility/LevelWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/LevelWrapper.java index 65d59193..88e46365 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/LevelWrapper.java +++ b/src/main/java/com/alrex/parcool/api/compatibility/LevelWrapper.java @@ -8,10 +8,7 @@ import net.minecraft.block.BlockState; import net.minecraft.client.Minecraft; import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.particles.BasicParticleType; -import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.IParticleData; -import net.minecraft.tileentity.TileEntity; import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; @@ -50,8 +47,8 @@ public boolean isClientSide() { return level.isClientSide(); } - public TileEntity getBlockEntity(BlockPos pos) { - return level.getBlockEntity(pos); + public BlockEntityWrapper getBlockEntity(BlockPos pos) { + return new BlockEntityWrapper(level.getBlockEntity(pos)); } public static LevelWrapper get() { @@ -69,4 +66,8 @@ public boolean noCollision(AxisAlignedBB expandTowards) { public List getEntitiesOfClass(Class class1, AxisAlignedBB inflate) { return level.getEntitiesOfClass(class1, inflate); } + + public World getInstance() { + return level; + } } diff --git a/src/main/java/com/alrex/parcool/client/renderer/Renderers.java b/src/main/java/com/alrex/parcool/client/renderer/Renderers.java index 8c89a721..52201f86 100644 --- a/src/main/java/com/alrex/parcool/client/renderer/Renderers.java +++ b/src/main/java/com/alrex/parcool/client/renderer/Renderers.java @@ -1,7 +1,7 @@ package com.alrex.parcool.client.renderer; import com.alrex.parcool.client.renderer.entity.ZiplineRopeRenderer; -import com.alrex.parcool.common.entity.EntityType; +import com.alrex.parcool.common.entity.ParcoolEntityType; import net.minecraft.client.renderer.entity.EntityRendererManager; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -9,6 +9,6 @@ @OnlyIn(Dist.CLIENT) public class Renderers { public static void register(EntityRendererManager manager) { - manager.register(EntityType.ZIPLINE_ROPE.get(), new ZiplineRopeRenderer(manager)); + manager.register(ParcoolEntityType.ZIPLINE_ROPE.get(), new ZiplineRopeRenderer(manager)); } } diff --git a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java index 0f13cfde..3286d69d 100644 --- a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java +++ b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java @@ -1,6 +1,9 @@ package com.alrex.parcool.common.block.zipline; import com.alrex.parcool.api.SoundEvents; +import com.alrex.parcool.api.compatibility.BlockEntityWrapper; +import com.alrex.parcool.api.compatibility.ContainersWrapper; +import com.alrex.parcool.api.compatibility.InteractionResultWrapper; import com.alrex.parcool.api.compatibility.LevelWrapper; import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.compatibility.Vec3Wrapper; @@ -11,7 +14,6 @@ import net.minecraft.block.DirectionalBlock; import net.minecraft.block.material.PushReaction; import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.inventory.InventoryHelper; import net.minecraft.item.BlockItemUseContext; import net.minecraft.item.ItemStack; import net.minecraft.item.ShearsItem; @@ -27,7 +29,6 @@ import net.minecraft.world.IWorld; import net.minecraft.world.IWorldReader; import net.minecraft.world.World; - import javax.annotation.Nonnull; import javax.annotation.Nullable; import java.util.List; @@ -63,11 +64,11 @@ public BlockState getStateForPlacement(BlockItemUseContext context) { public void onRemove(@Nonnull BlockState state, @Nonnull World world, @Nonnull BlockPos pos, @Nonnull BlockState p_196243_4_, boolean p_196243_5_) { LevelWrapper level = LevelWrapper.get(world); if (!level.isClientSide()) { - TileEntity tileEntity = level.getBlockEntity(pos); - if (tileEntity instanceof ZiplineHookTileEntity) { - ZiplineHookTileEntity ziplineHookTileEntity = (ZiplineHookTileEntity) tileEntity; + BlockEntityWrapper tileEntity = level.getBlockEntity(pos); + ZiplineHookTileEntity ziplineHookTileEntity = tileEntity.cast(ZiplineHookTileEntity.class); + if (ziplineHookTileEntity != null) { List itemStacks = ziplineHookTileEntity.removeAllConnection(); - itemStacks.forEach((it) -> InventoryHelper.dropItemStack(world, pos.getX(), pos.getY(), pos.getZ(), it)); + itemStacks.forEach((it) -> ContainersWrapper.dropItemStack(world, pos.getX(), pos.getY(), pos.getZ(), it)); } } super.onRemove(state, world, pos, p_196243_4_, p_196243_5_); @@ -97,26 +98,23 @@ public ActionResultType use(BlockState blockState, World world, BlockPos pos, Pl PlayerWrapper player = PlayerWrapper.get(playerEntity); ItemStack stack = player.getItemInHand(hand); if (stack.getItem() instanceof ShearsItem) { - TileEntity tileEntity = level.getBlockEntity(pos); - if (tileEntity instanceof ZiplineHookTileEntity) { - ZiplineHookTileEntity ziplineHookTileEntity = (ZiplineHookTileEntity) tileEntity; - if (ziplineHookTileEntity.getConnectionPoints().isEmpty()) return ActionResultType.PASS; + BlockEntityWrapper tileEntity = level.getBlockEntity(pos); + ZiplineHookTileEntity ziplineHookTileEntity = tileEntity.cast(ZiplineHookTileEntity.class); + if (ziplineHookTileEntity != null) { + if (ziplineHookTileEntity.getConnectionPoints().isEmpty()) return InteractionResultWrapper.PASS; List itemStacks = ziplineHookTileEntity.removeAllConnection(); player.playSound(SoundEvents.ZIPLINE_REMOVE.get(), 1, 1); - if (world.isClientSide()) { - return ActionResultType.SUCCESS; - } else { - itemStacks.forEach((it) -> InventoryHelper.dropItemStack(world, pos.getX(), pos.getY(), pos.getZ(), it)); - if (!itemStacks.isEmpty() && stack.isDamageableItem()) { - player.hurtAndBreakStack(1, stack); - } - return ActionResultType.CONSUME; + if (world.isClientSide()) return InteractionResultWrapper.SUCCESS; + itemStacks.forEach((it) -> ContainersWrapper.dropItemStack(world, pos.getX(), pos.getY(), pos.getZ(), it)); + if (!itemStacks.isEmpty() && stack.isDamageableItem()) { + player.hurtAndBreakStack(1, stack); } + return InteractionResultWrapper.CONSUME; } } - return ActionResultType.PASS; + return InteractionResultWrapper.PASS; } @Override diff --git a/src/main/java/com/alrex/parcool/common/entity/EntityType.java b/src/main/java/com/alrex/parcool/common/entity/ParcoolEntityType.java similarity index 75% rename from src/main/java/com/alrex/parcool/common/entity/EntityType.java rename to src/main/java/com/alrex/parcool/common/entity/ParcoolEntityType.java index e73d7c40..5acb82bc 100644 --- a/src/main/java/com/alrex/parcool/common/entity/EntityType.java +++ b/src/main/java/com/alrex/parcool/common/entity/ParcoolEntityType.java @@ -3,14 +3,15 @@ import com.alrex.parcool.ParCool; import com.alrex.parcool.common.entity.zipline.ZiplineRopeEntity; import net.minecraft.entity.EntityClassification; +import net.minecraft.entity.EntityType; import net.minecraftforge.eventbus.api.IEventBus; import net.minecraftforge.fml.RegistryObject; import net.minecraftforge.registries.DeferredRegister; import net.minecraftforge.registries.ForgeRegistries; -public class EntityType { - private static final DeferredRegister> REGISTER = DeferredRegister.create(ForgeRegistries.ENTITIES, ParCool.MOD_ID); - public static final RegistryObject> ZIPLINE_ROPE +public class ParcoolEntityType { + private static final DeferredRegister> REGISTER = DeferredRegister.create(ForgeRegistries.ENTITIES, ParCool.MOD_ID); + public static final RegistryObject> ZIPLINE_ROPE = REGISTER.register("zipline_rope", () -> net.minecraft.entity.EntityType.Builder .of((net.minecraft.entity.EntityType.IFactory) ZiplineRopeEntity::new, EntityClassification.MISC) .noSave() diff --git a/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java b/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java index f58af6a3..c2e4f6c5 100644 --- a/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java +++ b/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java @@ -46,7 +46,7 @@ public ZiplineRopeEntity(EntityType p_i48580_1_, World p_i48580_2_) { } public ZiplineRopeEntity(World world, BlockPos start, BlockPos end, ZiplineInfo info) { - super(com.alrex.parcool.common.entity.EntityType.ZIPLINE_ROPE.get(), world); + super(com.alrex.parcool.common.entity.ParcoolEntityType.ZIPLINE_ROPE.get(), world); setStartPos(start); setEndPos(end); setColor(info.getColor()); From a27382cb08cef62bc8e50df76887e2d9e219055a Mon Sep 17 00:00:00 2001 From: Thiago Santos Date: Fri, 2 May 2025 10:28:12 -0300 Subject: [PATCH 6/8] refactor: fixing WeakCache loophole --- .../AbstractClientPlayerWrapper.java | 8 +- .../compatibility/ClientPlayerWrapper.java | 19 ++-- .../api/compatibility/EntityWrapper.java | 76 +++++++-------- .../api/compatibility/LevelWrapper.java | 25 ++--- .../compatibility/LivingEntityWrapper.java | 34 ++++--- .../api/compatibility/PlayerWrapper.java | 92 ++++++++++--------- 6 files changed, 138 insertions(+), 116 deletions(-) diff --git a/src/main/java/com/alrex/parcool/api/compatibility/AbstractClientPlayerWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/AbstractClientPlayerWrapper.java index bca2bc19..c7ee9e50 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/AbstractClientPlayerWrapper.java +++ b/src/main/java/com/alrex/parcool/api/compatibility/AbstractClientPlayerWrapper.java @@ -1,15 +1,17 @@ package com.alrex.parcool.api.compatibility; +import java.lang.ref.WeakReference; + import net.minecraft.client.entity.player.AbstractClientPlayerEntity; import net.minecraftforge.event.TickEvent.PlayerTickEvent; public class AbstractClientPlayerWrapper extends PlayerWrapper { - private AbstractClientPlayerEntity player; + private WeakReference player; private static final WeakCache cache = new WeakCache<>(); protected AbstractClientPlayerWrapper(AbstractClientPlayerEntity player) { super(player); - this.player = player; + this.player = new WeakReference<>(player); } public static AbstractClientPlayerWrapper get(AbstractClientPlayerEntity player) { @@ -21,6 +23,6 @@ public static AbstractClientPlayerWrapper get(PlayerTickEvent event) { } public AbstractClientPlayerEntity getInstance() { - return this.player; + return this.player.get(); } } diff --git a/src/main/java/com/alrex/parcool/api/compatibility/ClientPlayerWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/ClientPlayerWrapper.java index 0e9877e6..dd9b4a10 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/ClientPlayerWrapper.java +++ b/src/main/java/com/alrex/parcool/api/compatibility/ClientPlayerWrapper.java @@ -1,5 +1,7 @@ package com.alrex.parcool.api.compatibility; +import java.lang.ref.WeakReference; + import javax.annotation.Nullable; import net.minecraft.client.Minecraft; import net.minecraft.client.entity.player.AbstractClientPlayerEntity; @@ -9,12 +11,12 @@ public class ClientPlayerWrapper extends AbstractClientPlayerWrapper { private static final Minecraft mc = Minecraft.getInstance(); - private ClientPlayerEntity player; + private WeakReference playerRef; private static final WeakCache cache = new WeakCache<>(); public ClientPlayerWrapper(ClientPlayerEntity player) { super(player); - this.player = player; + this.playerRef = new WeakReference<>(player); } // All static get methods grouped together @@ -63,27 +65,28 @@ public static boolean is(EntityWrapper playerWrapper) { // All get methods grouped together @Override public ClientPlayerEntity getInstance() { - return player; + return playerRef.get(); } public double getLeftImpulse() { - return player.input.leftImpulse; + return playerRef.get().input.leftImpulse; } public double getForwardImpulse() { - return player.input.forwardImpulse; + return playerRef.get().input.forwardImpulse; } public long getGameTime() { - return player.level.getGameTime(); + return playerRef.get().level.getGameTime(); } // All is/has methods grouped together public boolean isSprinting() { - return player.isSprinting(); + return playerRef.get().isSprinting(); } public boolean isAnyMoveKeyDown() { + ClientPlayerEntity player = playerRef.get(); return player.input.up || player.input.down || player.input.left @@ -91,6 +94,6 @@ public boolean isAnyMoveKeyDown() { } public boolean hasForwardImpulse() { - return player.input.hasForwardImpulse(); + return playerRef.get().input.hasForwardImpulse(); } } diff --git a/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java index 023997e2..185bfe6f 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java +++ b/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java @@ -1,5 +1,6 @@ package com.alrex.parcool.api.compatibility; +import java.lang.ref.WeakReference; import java.util.UUID; import javax.annotation.Nonnull; @@ -18,11 +19,11 @@ public class EntityWrapper { - private Entity entity; + private final WeakReference entityRef; protected static final WeakCache cache = new WeakCache<>(); protected EntityWrapper(Entity entity) { - this.entity = entity; + this.entityRef = new WeakReference<>(entity); } // Static get methods @@ -32,19 +33,20 @@ public static EntityWrapper get(Entity entity) { // add methods grouped together public void addParticle(BasicParticleType endRod, double x, double d, double z, double e, double f, double g) { - entity.level.addParticle(endRod, x, d, z, e, f, g); + entityRef.get().level.addParticle(endRod, x, d, z, e, f, g); } public void addToDeltaMovement(int i, double d, int j) { - entity.setDeltaMovement(entity.getDeltaMovement().add(i, d, j)); + entityRef.get().setDeltaMovement(entityRef.get().getDeltaMovement().add(i, d, j)); } public void addToDeltaMovement(Vec3Wrapper vec) { - entity.setDeltaMovement(entity.getDeltaMovement().add(vec)); + entityRef.get().setDeltaMovement(entityRef.get().getDeltaMovement().add(vec)); } // get methods grouped together public BlockPos getAdjustedBlockPos(int xDirection, double minY, int zDirection) { + Entity entity = entityRef.get(); return new BlockPos( entity.getX() + xDirection, entity.getBoundingBox().minY + minY, @@ -53,46 +55,47 @@ public BlockPos getAdjustedBlockPos(int xDirection, double minY, int zDirection) } public float getBbHeight() { - return entity.getBbHeight(); + return entityRef.get().getBbHeight(); } public float getBbWidth() { - return entity.getBbWidth(); + return entityRef.get().getBbWidth(); } public BlockState getBlockState(BlockPos pos) { - return entity.level.getBlockState(pos); + return entityRef.get().level.getBlockState(pos); } @Nullable public T getCapability(@Nonnull final Capability cap) { - LazyOptional optional = entity.getCapability(cap); + LazyOptional optional = entityRef.get().getCapability(cap); if (!optional.isPresent()) return null; return optional.orElse(null); } public Vec3Wrapper getDeltaMovement() { - return new Vec3Wrapper(entity.getDeltaMovement()); + return new Vec3Wrapper(entityRef.get().getDeltaMovement()); } public float getEyeHeight() { - return entity.getEyeHeight(); + return entityRef.get().getEyeHeight(); } public float getFallDistance() { - return entity.fallDistance; + return entityRef.get().fallDistance; } public LevelWrapper getLevel() { - return LevelWrapper.get(entity.level); + return LevelWrapper.get(entityRef.get().level); } public Vec3Wrapper getLookAngle() { - return new Vec3Wrapper(entity.getLookAngle()); + return new Vec3Wrapper(entityRef.get().getLookAngle()); } public float getMinSlipperiness(BlockPos ...blockPos) { float minSlipperiness = 1; + Entity entity = entityRef.get(); for (BlockPos pos : blockPos) { if (entity.level.isLoaded(pos)) { float candidateSlipperiness = entity.level.getBlockState(pos).getSlipperiness(entity.level, pos, entity); @@ -103,49 +106,49 @@ public float getMinSlipperiness(BlockPos ...blockPos) { } public float getRotatedYRot(PlayerModelRotator rotator) { - return 180f + MathHelper.lerp(rotator.getPartialTick(), entity.yRotO, entity.yRot); + return 180f + MathHelper.lerp(rotator.getPartialTick(), entityRef.get().yRotO, entityRef.get().yRot); } public int getTickCount() { - return entity.tickCount; + return entityRef.get().tickCount; } public UUID getUUID() { - return entity.getUUID(); + return entityRef.get().getUUID(); } public float getViewXRot(float renderPartialTicks) { - return entity.getViewXRot(renderPartialTicks); + return entityRef.get().getViewXRot(renderPartialTicks); } public float getYHeadRot() { - return entity.getYHeadRot(); + return entityRef.get().getYHeadRot(); } public float getYRot() { - return entity.yRot; + return entityRef.get().yRot; } public double getX() { - return entity.getX(); + return entityRef.get().getX(); } public double getY() { - return entity.getY(); + return entityRef.get().getY(); } public double getZ() { - return entity.getZ(); + return entityRef.get().getZ(); } public Entity getInstance() { - return entity; + return entityRef.get(); } // is methods grouped together public boolean isEveryLoaded(BlockPos ...blockPos) { for (BlockPos pos : blockPos) { - if (!entity.level.isLoaded(pos)) { + if (!entityRef.get().level.isLoaded(pos)) { return false; } } @@ -153,51 +156,52 @@ public boolean isEveryLoaded(BlockPos ...blockPos) { } public boolean isInLava() { - return entity.isInLava(); + return entityRef.get().isInLava(); } public boolean isInWaterOrBubble() { - return entity.isInWaterOrBubble(); + return entityRef.get().isInWaterOrBubble(); } public boolean isOnGround() { - return entity.isOnGround(); + return entityRef.get().isOnGround(); } public boolean isVisuallyCrawling() { - return entity.isVisuallyCrawling(); + return entityRef.get().isVisuallyCrawling(); } public boolean isVisuallySwimming() { - return entity.isVisuallySwimming(); + return entityRef.get().isVisuallySwimming(); } // Other methods public void multiplyDeltaMovement(double d, int i, double e) { + Entity entity = entityRef.get(); entity.setDeltaMovement(entity.getDeltaMovement().multiply(d, i, e)); } public boolean noCollision(AxisAlignedBB bb) { - return entity.level.noCollision(bb); + return entityRef.get().level.noCollision(bb); } public void playSound(SoundEvent soundEvent, float i, float j) { - entity.playSound(soundEvent, i, j); + entityRef.get().playSound(soundEvent, i, j); } public Vec3Wrapper position() { - return new Vec3Wrapper(entity.position()); + return new Vec3Wrapper(entityRef.get().position()); } public void resetFallDistance() { - entity.fallDistance = 0; + entityRef.get().fallDistance = 0; } public void setDeltaMovement(double x, double i, double z) { - entity.setDeltaMovement(x, i, z); + entityRef.get().setDeltaMovement(x, i, z); } public void setYBodyRot(float f) { - entity.setYBodyRot(f); + entityRef.get().setYBodyRot(f); } } diff --git a/src/main/java/com/alrex/parcool/api/compatibility/LevelWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/LevelWrapper.java index 88e46365..eeab328d 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/LevelWrapper.java +++ b/src/main/java/com/alrex/parcool/api/compatibility/LevelWrapper.java @@ -1,5 +1,6 @@ package com.alrex.parcool.api.compatibility; +import java.lang.ref.WeakReference; import java.util.List; import java.util.UUID; @@ -14,12 +15,12 @@ import net.minecraft.world.World; public final class LevelWrapper { - private World level; + private WeakReference level; private static final WeakCache cache = new WeakCache<>(); private static final Minecraft mc = Minecraft.getInstance(); public LevelWrapper(World level) { - this.level = level; + this.level = new WeakReference<>(level); } public static LevelWrapper get(World level) { @@ -27,28 +28,28 @@ public static LevelWrapper get(World level) { } public PlayerEntity getPlayerByUUID(UUID playerID) { - return level.getPlayerByUUID(playerID); + return level.get().getPlayerByUUID(playerID); } public void addParticle(IParticleData drippingWater, double d, double e, double f, double x, double g, double z) { - level.addParticle(drippingWater, d, e, f, x, g, z); + level.get().addParticle(drippingWater, d, e, f, x, g, z); } public boolean isLoaded(BlockPos blockpos) { - return level.isLoaded(blockpos); + return level.get().isLoaded(blockpos); } public BlockState getBlockState(BlockPos blockpos) { - return level.getBlockState(blockpos); + return level.get().getBlockState(blockpos); } public boolean isClientSide() { - return level.isClientSide(); + return level.get().isClientSide(); } public BlockEntityWrapper getBlockEntity(BlockPos pos) { - return new BlockEntityWrapper(level.getBlockEntity(pos)); + return new BlockEntityWrapper(level.get().getBlockEntity(pos)); } public static LevelWrapper get() { @@ -56,18 +57,18 @@ public static LevelWrapper get() { } public boolean isCollisionShapeFullBlock(BlockState state, BlockPos pos) { - return state.isCollisionShapeFullBlock(level, pos); + return state.isCollisionShapeFullBlock(level.get(), pos); } public boolean noCollision(AxisAlignedBB expandTowards) { - return level.noCollision(expandTowards); + return level.get().noCollision(expandTowards); } public List getEntitiesOfClass(Class class1, AxisAlignedBB inflate) { - return level.getEntitiesOfClass(class1, inflate); + return level.get().getEntitiesOfClass(class1, inflate); } public World getInstance() { - return level; + return level.get(); } } diff --git a/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java index 29c4a6d8..ce5bdcc7 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java +++ b/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java @@ -1,5 +1,6 @@ package com.alrex.parcool.api.compatibility; +import java.lang.ref.WeakReference; import java.util.Random; import javax.annotation.Nonnull; @@ -19,49 +20,51 @@ public class LivingEntityWrapper extends EntityWrapper { - private LivingEntity entity; + private WeakReference entityRef; private static final WeakCache cache = new WeakCache<>(); protected LivingEntityWrapper(LivingEntity entity) { super(entity); - this.entity = entity; + this.entityRef = new WeakReference<>(entity); } // All get methods grouped together @Override public LivingEntity getInstance() { - return entity; + return entityRef.get(); } public ModifiableAttributeInstance getAttribute(Attribute attribute) { - return entity.getAttribute(attribute); + return entityRef.get().getAttribute(attribute); } public double getAttributeValue(Attribute attribute) { - return entity.getAttributeValue(attribute); + return entityRef.get().getAttributeValue(attribute); } public AxisAlignedBB getBoundingBox() { - return entity.getBoundingBox(); + return entityRef.get().getBoundingBox(); } public double getGravity() { - return entity.getAttributeValue(ForgeMod.ENTITY_GRAVITY.get()); + return entityRef.get().getAttributeValue(ForgeMod.ENTITY_GRAVITY.get()); } public HandSide getMainArm() { - return entity.getMainArm(); + return entityRef.get().getMainArm(); } public Random getRandom() { - return entity.getRandom(); + return entityRef.get().getRandom(); } public Vec3Wrapper getRotatedBodyAngle(PlayerModelRotator rotator) { + LivingEntity entity = entityRef.get(); return new Vec3Wrapper(VectorUtil.fromYawDegree(MathUtil.lerp(entity.yBodyRotO, entity.yBodyRot, rotator.getPartialTick()))); } public double getUpdatedYRotDifference() { + LivingEntity entity = entityRef.get(); Vec3Wrapper currentAngle = VectorUtil.fromYawDegree(entity.yBodyRot); Vec3Wrapper oldAngle = VectorUtil.fromYawDegree(entity.yBodyRotO); return Math.atan( @@ -71,11 +74,11 @@ public double getUpdatedYRotDifference() { } public Vec3Wrapper getVectorYBodyRot() { - return new Vec3Wrapper(VectorUtil.fromYawDegree(entity.yBodyRot)); + return new Vec3Wrapper(VectorUtil.fromYawDegree(entityRef.get().yBodyRot)); } public float getYBodyRot() { - return entity.yBodyRot; + return entityRef.get().yBodyRot; } // Static get methods @@ -89,23 +92,24 @@ public static LivingEntityWrapper get(Entity entity) { // Has/is boolean methods public boolean hasEffect(Effect effect) { - return entity.hasEffect(effect); + return entityRef.get().hasEffect(effect); } public boolean isFallFlying() { - return entity.isFallFlying(); + return entityRef.get().isFallFlying(); } public boolean isSpectator() { - return entity.isSpectator(); + return entityRef.get().isSpectator(); } public boolean isSwingingMainHand() { - return entity.swingingArm == Hand.MAIN_HAND; + return entityRef.get().swingingArm == Hand.MAIN_HAND; } // Update methods public void updateBodyRot() { + LivingEntity entity = entityRef.get(); entity.yBodyRot = entity.yRot; entity.yBodyRotO = entity.yRotO; } diff --git a/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java b/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java index 6e077f0a..ce96b5f9 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java +++ b/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java @@ -1,5 +1,6 @@ package com.alrex.parcool.api.compatibility; +import java.lang.ref.WeakReference; import java.util.UUID; import java.util.function.Consumer; import java.util.function.Supplier; @@ -30,62 +31,64 @@ public class PlayerWrapper extends LivingEntityWrapper { - private PlayerEntity player; + private WeakReference playerRef; protected static final WeakCache cache = new WeakCache<>(); public PlayerWrapper(PlayerEntity player) { super(player); - this.player = player; + this.playerRef = new WeakReference(player); } // All get methods grouped together @Override public PlayerEntity getInstance() { - return player; + return playerRef.get(); } public BlockState getBelowBlockState() { + PlayerEntity player = playerRef.get(); return player.level.getBlockState(player.blockPosition().below()); } public float getEyeHeight() { - return player.getEyeHeight(Pose.STANDING); + return playerRef.get().getEyeHeight(Pose.STANDING); } public float getFallDistance() { - return player.fallDistance; + return playerRef.get().fallDistance; } public int getFoodLevel() { - return player.getFoodData().getFoodLevel(); + return playerRef.get().getFoodData().getFoodLevel(); } public ItemStack getItemInHand(Hand hand) { - return player.getItemInHand(hand); + return playerRef.get().getItemInHand(hand); } public String getName() { - return player.getGameProfile().getName(); + return playerRef.get().getGameProfile().getName(); } public Pose getPose() { - return player.getPose(); + return playerRef.get().getPose(); } public float getSlipperiness(BlockPos leanedBlock) { + PlayerEntity player = playerRef.get(); return player.level.getBlockState(leanedBlock).getSlipperiness(player.level, leanedBlock, player); } public int getTickCount() { - return player.tickCount; + return playerRef.get().tickCount; } public Object getVehicle() { - return player.getVehicle(); + return playerRef.get().getVehicle(); } public Iterable getPlayersOnSameLevel() { - return MinecraftServerWrapper.getPlayers(player.level.players()); + return MinecraftServerWrapper.getPlayers(playerRef.get().level.players()); } // All static get methods grouped together @@ -176,71 +179,73 @@ public static PlayerWrapper getFromEntityOrDefault(LivingEvent event) { // All has/is boolean methods grouped public boolean hasHurtTime() { - return player.hurtTime > 0; + return playerRef.get().hurtTime > 0; } public boolean hasNoPhysics() { - return player.noPhysics; + return playerRef.get().noPhysics; } public boolean hasSomeCollision() { + PlayerEntity player = playerRef.get(); return player.horizontalCollision || player.verticalCollision; } public boolean isCreative() { - return player.isCreative(); + return playerRef.get().isCreative(); } public boolean isCrouching() { - return player.isCrouching(); + return playerRef.get().isCrouching(); } public boolean isFallFlying() { - return player.isFallFlying(); + return playerRef.get().isFallFlying(); } public boolean isFlying() { - return player.abilities.flying; + return playerRef.get().abilities.flying; } public boolean isImmortal() { + PlayerEntity player = playerRef.get(); return player.isSpectator() || player.isCreative(); } public boolean isInWall() { - return player.isInWall(); + return playerRef.get().isInWall(); } public boolean isInWater() { - return player.isInWater(); + return playerRef.get().isInWater(); } public boolean isLevelClientSide() { - return player.level.isClientSide; + return playerRef.get().level.isClientSide; } public boolean isLocalPlayer() { - return player.isLocalPlayer(); + return playerRef.get().isLocalPlayer(); } public boolean isOnGround() { - return player.isOnGround(); + return playerRef.get().isOnGround(); } public boolean isPassenger() { - return player.isPassenger(); + return playerRef.get().isPassenger(); } public boolean isShiftKeyDown() { - return player.isShiftKeyDown(); + return playerRef.get().isShiftKeyDown(); } public boolean isSprinting() { - return player.isSprinting(); + return playerRef.get().isSprinting(); } public boolean isSwimming() { - return player.isSwimming(); + return playerRef.get().isSwimming(); } public static boolean is(LivingEntityWrapper entity) { @@ -248,42 +253,43 @@ public static boolean is(LivingEntityWrapper entity) { } public boolean onClimbable() { - return player.onClimbable(); + return playerRef.get().onClimbable(); } // All set methods grouped public void setAllYBodyRot(float bodyYaw) { + PlayerEntity player = playerRef.get(); player.yBodyRot = bodyYaw; player.yBodyRotO = bodyYaw; } public void setDeltaMovement(Vec3Wrapper vec) { - player.setDeltaMovement(vec); + playerRef.get().setDeltaMovement(vec); } public void setPos(Vec3Wrapper hidingPoint) { - player.setPos(hidingPoint.x(), hidingPoint.y(), hidingPoint.z()); + playerRef.get().setPos(hidingPoint.x(), hidingPoint.y(), hidingPoint.z()); } public void setSprinting(boolean b) { - player.setSprinting(true); + playerRef.get().setSprinting(true); } public void setStandingPose() { - player.setPose(Pose.STANDING); + playerRef.get().setPose(Pose.STANDING); } public void setSwimming() { - player.setSprinting(false); - player.setPose(Pose.SWIMMING); + playerRef.get().setSprinting(false); + playerRef.get().setPose(Pose.SWIMMING); } public void setYHeadRot(float yawDegree) { - player.yHeadRot = yawDegree; + playerRef.get().yHeadRot = yawDegree; } public void setYRot(double yawDegree) { - player.yRot = (float)yawDegree; + playerRef.get().yRot = (float)yawDegree; } // All hurt methods grouped @@ -294,23 +300,24 @@ public void hurtAndBreakStack(int quantity, ItemStack stack) { } public void hurtAndBreakStack(int quantity, ItemStack stack, Consumer consumer) { - stack.hurtAndBreak(quantity, player, (it) -> consumer.accept(get(it))); + stack.hurtAndBreak(quantity, playerRef.get(), (it) -> consumer.accept(get(it))); } // Remaining methods public void displayClientMessage(IFormattableTextComponent translationTextComponent, boolean b) { - player.displayClientMessage(translationTextComponent, b); + playerRef.get().displayClientMessage(translationTextComponent, b); } public void disablePhysics() { - player.noPhysics = true; + playerRef.get().noPhysics = true; } public void enablePhysics() { - player.noPhysics = false; + playerRef.get().noPhysics = false; } public void forceDamage(DamageSource source, float f) { + PlayerEntity player = playerRef.get(); int invulnerableTime = player.invulnerableTime; // bypass invulnerableTime player.invulnerableTime = 0; player.hurt(source, f); @@ -318,14 +325,15 @@ public void forceDamage(DamageSource source, float f) { } public void jumpFromGround() { - player.jumpFromGround(); + playerRef.get().jumpFromGround(); } public void multiplyFallDistance(float multiplier) { - player.fallDistance *= multiplier; + playerRef.get().fallDistance *= multiplier; } public void rotateBodyRot0(Vec3Wrapper direction, double d) { + PlayerEntity player = playerRef.get(); player.yBodyRotO = player.yBodyRot = (float) VectorUtil.toYawDegree(direction.yRot((float) d)); } } From ab476e543a01d6326c67a0e2f3a2cbd5295f8e92 Mon Sep 17 00:00:00 2001 From: Thiago Santos Date: Sat, 3 May 2025 10:41:00 -0300 Subject: [PATCH 7/8] refactor: moving compatibility out of api --- src/main/java/com/alrex/parcool/api/Stamina.java | 3 ++- .../com/alrex/parcool/api/unstable/Limitation.java | 4 ++-- .../api/unstable/action/ParCoolActionEvent.java | 3 ++- .../animation/ParCoolAnimationInfoEvent.java | 3 ++- .../alrex/parcool/client/animation/Animator.java | 3 ++- .../client/animation/PassiveCustomAnimation.java | 6 +++--- .../client/animation/PlayerModelRotator.java | 6 +++--- .../client/animation/PlayerModelTransformer.java | 2 +- .../animation/impl/BackwardWallJumpAnimator.java | 2 +- .../client/animation/impl/CatLeapAnimator.java | 3 +-- .../client/animation/impl/ChargeJumpAnimator.java | 2 +- .../client/animation/impl/ClimbUpAnimator.java | 2 +- .../client/animation/impl/ClingToCliffAnimator.java | 2 +- .../client/animation/impl/CrawlAnimator.java | 2 +- .../animation/impl/DiveAnimationHostAnimator.java | 2 +- .../animation/impl/DiveIntoWaterAnimator.java | 2 +- .../client/animation/impl/DodgeAnimator.java | 2 +- .../impl/ExaggeratedSideDodgeAnimator.java | 2 +- .../client/animation/impl/FastRunningAnimator.java | 4 ++-- .../client/animation/impl/FastSwimAnimator.java | 4 ++-- .../client/animation/impl/FlippingAnimator.java | 2 +- .../parcool/client/animation/impl/HangAnimator.java | 2 +- .../client/animation/impl/HideInBlockAnimator.java | 4 ++-- .../animation/impl/HorizontalWallRunAnimator.java | 2 +- .../client/animation/impl/JumpChargingAnimator.java | 2 +- .../client/animation/impl/JumpFromBarAnimator.java | 2 +- .../client/animation/impl/KongVaultAnimator.java | 2 +- .../client/animation/impl/RideZiplineAnimator.java | 6 +++--- .../parcool/client/animation/impl/RollAnimator.java | 2 +- .../client/animation/impl/SlidingAnimator.java | 4 ++-- .../client/animation/impl/SpeedVaultAnimator.java | 3 +-- .../parcool/client/animation/impl/TapAnimator.java | 2 +- .../animation/impl/VerticalWallRunAnimator.java | 2 +- .../client/animation/impl/WallJumpAnimator.java | 2 +- .../client/animation/impl/WallSlideAnimator.java | 4 ++-- .../client/gui/SettingActionLimitationScreen.java | 2 +- .../client/gui/SettingBooleanConfigScreen.java | 2 +- .../parcool/client/gui/SettingEnumConfigScreen.java | 2 +- .../parcool/client/hud/impl/LightStaminaHUD.java | 2 +- .../alrex/parcool/client/hud/impl/StaminaHUD.java | 2 +- .../client/hud/impl/StaminaHUDController.java | 2 +- .../client/renderer/entity/ZiplineRopeRenderer.java | 6 +++--- .../com/alrex/parcool/common/action/Action.java | 5 +++-- .../parcool/common/action/ActionProcessor.java | 9 +++++---- .../parcool/common/action/AdditionalProperties.java | 2 +- .../parcool/common/action/BehaviorEnforcer.java | 2 +- .../parcool/common/action/impl/BreakfallReady.java | 4 ++-- .../alrex/parcool/common/action/impl/CatLeap.java | 8 ++++---- .../parcool/common/action/impl/ChargeJump.java | 8 ++++---- .../parcool/common/action/impl/ClimbPoles.java | 2 +- .../alrex/parcool/common/action/impl/ClimbUp.java | 4 ++-- .../parcool/common/action/impl/ClingToCliff.java | 4 ++-- .../com/alrex/parcool/common/action/impl/Crawl.java | 2 +- .../com/alrex/parcool/common/action/impl/Dive.java | 2 +- .../com/alrex/parcool/common/action/impl/Dodge.java | 6 +++--- .../alrex/parcool/common/action/impl/FastRun.java | 2 +- .../alrex/parcool/common/action/impl/FastSwim.java | 2 +- .../alrex/parcool/common/action/impl/Flipping.java | 2 +- .../alrex/parcool/common/action/impl/HangDown.java | 4 ++-- .../parcool/common/action/impl/HideInBlock.java | 6 +++--- .../common/action/impl/HorizontalWallRun.java | 6 +++--- .../parcool/common/action/impl/JumpFromBar.java | 2 +- .../alrex/parcool/common/action/impl/QuickTurn.java | 4 ++-- .../parcool/common/action/impl/RideZipline.java | 4 ++-- .../com/alrex/parcool/common/action/impl/Roll.java | 6 +++--- .../alrex/parcool/common/action/impl/SkyDive.java | 6 +++--- .../com/alrex/parcool/common/action/impl/Slide.java | 6 +++--- .../com/alrex/parcool/common/action/impl/Tap.java | 2 +- .../com/alrex/parcool/common/action/impl/Vault.java | 4 ++-- .../parcool/common/action/impl/VerticalWallRun.java | 6 +++--- .../alrex/parcool/common/action/impl/WallJump.java | 6 +++--- .../alrex/parcool/common/action/impl/WallSlide.java | 6 +++--- .../common/block/zipline/IronZiplineHookBlock.java | 5 +++-- .../common/block/zipline/ZiplineHookBlock.java | 13 +++++++------ .../common/block/zipline/ZiplineHookTileEntity.java | 5 +++-- .../alrex/parcool/common/capability/Animation.java | 6 +++--- .../alrex/parcool/common/capability/IStamina.java | 5 +++-- .../parcool/common/capability/Parkourability.java | 5 +++-- .../common/capability/stamina/HungerStamina.java | 4 ++-- .../common/capability/stamina/OtherStamina.java | 5 +++-- .../parcool/common/capability/stamina/Stamina.java | 3 ++- .../common/entity/zipline/ZiplineRopeEntity.java | 5 +++-- .../common/handlers/AttachCapabilityHandler.java | 2 +- .../handlers/EnableOrDisableParCoolHandler.java | 2 +- .../alrex/parcool/common/handlers/InputHandler.java | 3 ++- .../parcool/common/handlers/LoginLogoutHandler.java | 4 ++-- .../common/handlers/OpenSettingsParCoolHandler.java | 2 +- .../parcool/common/handlers/PlayerCloneHandler.java | 5 +++-- .../common/handlers/PlayerDamageHandler.java | 4 ++-- .../parcool/common/handlers/PlayerJoinHandler.java | 5 +++-- .../parcool/common/handlers/PlayerJumpHandler.java | 3 ++- .../common/handlers/PlayerVisibilityHandler.java | 3 ++- .../alrex/parcool/common/info/ServerLimitation.java | 2 +- .../common/item/zipline/ZiplineRopeItem.java | 3 ++- .../common/network/StartBreakfallMessage.java | 9 +++++---- .../common/network/SyncActionStateMessage.java | 7 ++++--- .../network/SyncClientInformationMessage.java | 8 ++++---- .../common/network/SyncServerInfoMessage.java | 9 +++++---- .../parcool/common/network/SyncStaminaMessage.java | 7 ++++--- .../com/alrex/parcool/common/zipline/Zipline.java | 7 ++++--- .../alrex/parcool/common/zipline/ZiplineType.java | 3 ++- .../zipline/impl/GeneralQuadraticCurveZipline.java | 3 ++- .../common/zipline/impl/QuadraticCurveZipline.java | 3 ++- .../common/zipline/impl/StraightZipline.java | 3 ++- .../compatibility/AbstractClientPlayerWrapper.java | 2 +- .../{api => }/compatibility/AxisWrapper.java | 2 +- .../{api => }/compatibility/BlockEntityWrapper.java | 2 +- .../compatibility/ChannelInstanceWrapper.java | 2 +- .../compatibility/ClientPlayerWrapper.java | 2 +- .../{api => }/compatibility/ContainersWrapper.java | 2 +- .../{api => }/compatibility/EntityWrapper.java | 2 +- .../{api => }/compatibility/EventBusWrapper.java | 2 +- .../compatibility/InteractionResultWrapper.java | 2 +- .../{api => }/compatibility/LevelWrapper.java | 2 +- .../compatibility/LivingEntityWrapper.java | 2 +- .../compatibility/MinecraftServerWrapper.java | 2 +- .../compatibility/PlayerPacketDistributor.java | 2 +- .../{api => }/compatibility/PlayerWrapper.java | 2 +- .../compatibility/ServerPlayerWrapper.java | 2 +- .../{api => }/compatibility/Vec3Wrapper.java | 2 +- .../parcool/{api => }/compatibility/WeakCache.java | 2 +- .../betterthirdperson/BetterThirdPersonManager.java | 2 +- .../shouldersurfing/ShoulderSurfingManager.java | 2 +- .../mixin/client/ClientPlayerEntityMixin.java | 4 ++-- .../parcool/mixin/client/ClientWorldMixin.java | 3 ++- .../parcool/mixin/client/PlayerModelMixin.java | 2 +- .../parcool/mixin/client/PlayerRendererMixin.java | 2 +- .../com/alrex/parcool/mixin/common/EntityMixin.java | 3 ++- .../parcool/mixin/common/LivingEntityMixin.java | 9 +++++---- .../parcool/mixin/common/PlayerEntityMixin.java | 3 ++- .../command/impl/ControlLimitationCommand.java | 4 ++-- .../parcool/server/limitation/Limitations.java | 2 +- .../com/alrex/parcool/utilities/BipedModelUtil.java | 3 ++- .../com/alrex/parcool/utilities/BufferUtil.java | 2 +- .../com/alrex/parcool/utilities/EntityUtil.java | 4 ++-- .../com/alrex/parcool/utilities/VectorUtil.java | 2 +- .../java/com/alrex/parcool/utilities/WorldUtil.java | 9 +++++---- 137 files changed, 263 insertions(+), 230 deletions(-) rename src/main/java/com/alrex/parcool/{api => }/compatibility/AbstractClientPlayerWrapper.java (95%) rename src/main/java/com/alrex/parcool/{api => }/compatibility/AxisWrapper.java (96%) rename src/main/java/com/alrex/parcool/{api => }/compatibility/BlockEntityWrapper.java (90%) rename src/main/java/com/alrex/parcool/{api => }/compatibility/ChannelInstanceWrapper.java (89%) rename src/main/java/com/alrex/parcool/{api => }/compatibility/ClientPlayerWrapper.java (98%) rename src/main/java/com/alrex/parcool/{api => }/compatibility/ContainersWrapper.java (91%) rename src/main/java/com/alrex/parcool/{api => }/compatibility/EntityWrapper.java (99%) rename src/main/java/com/alrex/parcool/{api => }/compatibility/EventBusWrapper.java (95%) rename src/main/java/com/alrex/parcool/{api => }/compatibility/InteractionResultWrapper.java (89%) rename src/main/java/com/alrex/parcool/{api => }/compatibility/LevelWrapper.java (97%) rename src/main/java/com/alrex/parcool/{api => }/compatibility/LivingEntityWrapper.java (98%) rename src/main/java/com/alrex/parcool/{api => }/compatibility/MinecraftServerWrapper.java (98%) rename src/main/java/com/alrex/parcool/{api => }/compatibility/PlayerPacketDistributor.java (90%) rename src/main/java/com/alrex/parcool/{api => }/compatibility/PlayerWrapper.java (99%) rename src/main/java/com/alrex/parcool/{api => }/compatibility/ServerPlayerWrapper.java (98%) rename src/main/java/com/alrex/parcool/{api => }/compatibility/Vec3Wrapper.java (97%) rename src/main/java/com/alrex/parcool/{api => }/compatibility/WeakCache.java (93%) diff --git a/src/main/java/com/alrex/parcool/api/Stamina.java b/src/main/java/com/alrex/parcool/api/Stamina.java index 4098fc8d..484518bd 100644 --- a/src/main/java/com/alrex/parcool/api/Stamina.java +++ b/src/main/java/com/alrex/parcool/api/Stamina.java @@ -1,7 +1,8 @@ package com.alrex.parcool.api; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.IStamina; +import com.alrex.parcool.compatibility.PlayerWrapper; + import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; diff --git a/src/main/java/com/alrex/parcool/api/unstable/Limitation.java b/src/main/java/com/alrex/parcool/api/unstable/Limitation.java index fe11c6bc..3734c304 100644 --- a/src/main/java/com/alrex/parcool/api/unstable/Limitation.java +++ b/src/main/java/com/alrex/parcool/api/unstable/Limitation.java @@ -1,9 +1,9 @@ package com.alrex.parcool.api.unstable; import com.alrex.parcool.ParCool; -import com.alrex.parcool.api.compatibility.MinecraftServerWrapper; -import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.action.Action; +import com.alrex.parcool.compatibility.MinecraftServerWrapper; +import com.alrex.parcool.compatibility.ServerPlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.server.limitation.Limitations; import com.alrex.parcool.utilities.JsonWriterUtil; diff --git a/src/main/java/com/alrex/parcool/api/unstable/action/ParCoolActionEvent.java b/src/main/java/com/alrex/parcool/api/unstable/action/ParCoolActionEvent.java index 41e5952a..6b987b13 100644 --- a/src/main/java/com/alrex/parcool/api/unstable/action/ParCoolActionEvent.java +++ b/src/main/java/com/alrex/parcool/api/unstable/action/ParCoolActionEvent.java @@ -1,7 +1,8 @@ package com.alrex.parcool.api.unstable.action; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.Action; +import com.alrex.parcool.compatibility.PlayerWrapper; + import net.minecraftforge.eventbus.api.Cancelable; import net.minecraftforge.eventbus.api.Event; diff --git a/src/main/java/com/alrex/parcool/api/unstable/animation/ParCoolAnimationInfoEvent.java b/src/main/java/com/alrex/parcool/api/unstable/animation/ParCoolAnimationInfoEvent.java index 8f942930..8b6d8314 100644 --- a/src/main/java/com/alrex/parcool/api/unstable/animation/ParCoolAnimationInfoEvent.java +++ b/src/main/java/com/alrex/parcool/api/unstable/animation/ParCoolAnimationInfoEvent.java @@ -1,7 +1,8 @@ package com.alrex.parcool.api.unstable.animation; -import com.alrex.parcool.api.compatibility.AbstractClientPlayerWrapper; import com.alrex.parcool.client.animation.Animator; +import com.alrex.parcool.compatibility.AbstractClientPlayerWrapper; + import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.eventbus.api.Event; diff --git a/src/main/java/com/alrex/parcool/client/animation/Animator.java b/src/main/java/com/alrex/parcool/client/animation/Animator.java index 333ae58f..07ffa503 100644 --- a/src/main/java/com/alrex/parcool/client/animation/Animator.java +++ b/src/main/java/com/alrex/parcool/client/animation/Animator.java @@ -1,7 +1,8 @@ package com.alrex.parcool.client.animation; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; + import net.minecraftforge.client.event.EntityViewRenderEvent; import net.minecraftforge.event.TickEvent; diff --git a/src/main/java/com/alrex/parcool/client/animation/PassiveCustomAnimation.java b/src/main/java/com/alrex/parcool/client/animation/PassiveCustomAnimation.java index 9bb520e7..faaec861 100644 --- a/src/main/java/com/alrex/parcool/client/animation/PassiveCustomAnimation.java +++ b/src/main/java/com/alrex/parcool/client/animation/PassiveCustomAnimation.java @@ -1,12 +1,12 @@ package com.alrex.parcool.client.animation; -import com.alrex.parcool.api.compatibility.LevelWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.impl.ClingToCliff; import com.alrex.parcool.common.action.impl.Dive; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.EasingFunctions; import com.alrex.parcool.utilities.MathUtil; diff --git a/src/main/java/com/alrex/parcool/client/animation/PlayerModelRotator.java b/src/main/java/com/alrex/parcool/client/animation/PlayerModelRotator.java index c7b1242f..8acb8fe0 100644 --- a/src/main/java/com/alrex/parcool/client/animation/PlayerModelRotator.java +++ b/src/main/java/com/alrex/parcool/client/animation/PlayerModelRotator.java @@ -1,9 +1,9 @@ package com.alrex.parcool.client.animation; -import com.alrex.parcool.api.compatibility.AxisWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.api.unstable.animation.AnimationOption; +import com.alrex.parcool.compatibility.AxisWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.mojang.blaze3d.matrix.MatrixStack; public class PlayerModelRotator { diff --git a/src/main/java/com/alrex/parcool/client/animation/PlayerModelTransformer.java b/src/main/java/com/alrex/parcool/client/animation/PlayerModelTransformer.java index 904f5a6b..3dbc2092 100644 --- a/src/main/java/com/alrex/parcool/client/animation/PlayerModelTransformer.java +++ b/src/main/java/com/alrex/parcool/client/animation/PlayerModelTransformer.java @@ -1,8 +1,8 @@ package com.alrex.parcool.client.animation; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.unstable.animation.AnimationOption; import com.alrex.parcool.api.unstable.animation.AnimationPart; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.utilities.MathUtil; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.entity.model.PlayerModel; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/BackwardWallJumpAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/BackwardWallJumpAnimator.java index 2d45a2ca..555f1cde 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/BackwardWallJumpAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/BackwardWallJumpAnimator.java @@ -1,10 +1,10 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.EasingFunctions; import com.alrex.parcool.utilities.MathUtil; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/CatLeapAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/CatLeapAnimator.java index 707cc6e0..16675c6c 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/CatLeapAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/CatLeapAnimator.java @@ -4,13 +4,12 @@ import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.CatLeap; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.utilities.Easing; import com.alrex.parcool.utilities.EasingFunctions; import static com.alrex.parcool.utilities.MathUtil.lerp; -import com.alrex.parcool.api.compatibility.PlayerWrapper; - public class CatLeapAnimator extends Animator { @Override diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/ChargeJumpAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/ChargeJumpAnimator.java index 98e8a9c2..b30a061e 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/ChargeJumpAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/ChargeJumpAnimator.java @@ -1,11 +1,11 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.ChargeJump; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.utilities.Easing; public class ChargeJumpAnimator extends Animator { diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/ClimbUpAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/ClimbUpAnimator.java index 2e590dcf..896ce11a 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/ClimbUpAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/ClimbUpAnimator.java @@ -1,10 +1,10 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.utilities.EasingFunctions; import com.alrex.parcool.utilities.MathUtil; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/ClingToCliffAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/ClingToCliffAnimator.java index 6239d512..36db206e 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/ClingToCliffAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/ClingToCliffAnimator.java @@ -1,11 +1,11 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.ClingToCliff; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; public class ClingToCliffAnimator extends Animator { private final float Lean_Angle = 20; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/CrawlAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/CrawlAnimator.java index 2581141e..d43897ce 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/CrawlAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/CrawlAnimator.java @@ -1,10 +1,10 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.Crawl; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; public class CrawlAnimator extends Animator { @Override diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/DiveAnimationHostAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/DiveAnimationHostAnimator.java index e1c79e99..251342d4 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/DiveAnimationHostAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/DiveAnimationHostAnimator.java @@ -1,6 +1,5 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; @@ -8,6 +7,7 @@ import com.alrex.parcool.common.action.impl.Dive; import com.alrex.parcool.common.action.impl.SkyDive; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.utilities.Easing; import com.alrex.parcool.utilities.EasingFunctions; import com.alrex.parcool.utilities.MathUtil; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/DiveIntoWaterAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/DiveIntoWaterAnimator.java index 966d2e45..598b60a1 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/DiveIntoWaterAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/DiveIntoWaterAnimator.java @@ -1,10 +1,10 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.utilities.Easing; public class DiveIntoWaterAnimator extends Animator { diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/DodgeAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/DodgeAnimator.java index 7c51b4bb..c22065ec 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/DodgeAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/DodgeAnimator.java @@ -1,11 +1,11 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.Dodge; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.Easing; import net.minecraft.client.Minecraft; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/ExaggeratedSideDodgeAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/ExaggeratedSideDodgeAnimator.java index 74c3de6f..24807e3a 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/ExaggeratedSideDodgeAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/ExaggeratedSideDodgeAnimator.java @@ -1,11 +1,11 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.Dodge; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.utilities.Easing; import net.minecraftforge.event.TickEvent; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/FastRunningAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/FastRunningAnimator.java index c559f294..b033840f 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/FastRunningAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/FastRunningAnimator.java @@ -1,12 +1,12 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.FastRun; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.BipedModelUtil; import com.alrex.parcool.utilities.Easing; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/FastSwimAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/FastSwimAnimator.java index 4bcc9330..7ef73435 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/FastSwimAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/FastSwimAnimator.java @@ -1,12 +1,12 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.FastSwim; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.utilities.BipedModelUtil; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.entity.model.BipedModel; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/FlippingAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/FlippingAnimator.java index 54129f2e..2727dbe7 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/FlippingAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/FlippingAnimator.java @@ -1,11 +1,11 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.Flipping; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.EasingFunctions; import com.alrex.parcool.utilities.MathUtil; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/HangAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/HangAnimator.java index 0b0da41d..689dedbd 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/HangAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/HangAnimator.java @@ -1,11 +1,11 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.HangDown; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.client.Minecraft; import net.minecraftforge.client.event.EntityViewRenderEvent; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/HideInBlockAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/HideInBlockAnimator.java index e271eef8..f6e935c4 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/HideInBlockAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/HideInBlockAnimator.java @@ -1,12 +1,12 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.HideInBlock; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.utilities.Easing; import com.alrex.parcool.utilities.MathUtil; import com.alrex.parcool.utilities.VectorUtil; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/HorizontalWallRunAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/HorizontalWallRunAnimator.java index 035983da..648a070d 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/HorizontalWallRunAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/HorizontalWallRunAnimator.java @@ -1,11 +1,11 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.HorizontalWallRun; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.MathUtil; import net.minecraft.client.Minecraft; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/JumpChargingAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/JumpChargingAnimator.java index 20e66177..be72e1bc 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/JumpChargingAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/JumpChargingAnimator.java @@ -1,11 +1,11 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.ChargeJump; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.utilities.Easing; public class JumpChargingAnimator extends Animator { diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/JumpFromBarAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/JumpFromBarAnimator.java index d9ef9fac..c0d03a1a 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/JumpFromBarAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/JumpFromBarAnimator.java @@ -1,10 +1,10 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.utilities.EasingFunctions; import com.alrex.parcool.utilities.MathUtil; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/KongVaultAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/KongVaultAnimator.java index f3a84b99..92ea737b 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/KongVaultAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/KongVaultAnimator.java @@ -1,11 +1,11 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.Vault; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.Easing; import com.alrex.parcool.utilities.EasingFunctions; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/RideZiplineAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/RideZiplineAnimator.java index eb971501..7baae938 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/RideZiplineAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/RideZiplineAnimator.java @@ -1,13 +1,13 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.AxisWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.RideZipline; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.AxisWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.utilities.VectorUtil; import net.minecraft.util.math.MathHelper; import net.minecraftforge.event.TickEvent; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/RollAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/RollAnimator.java index a131e9a0..79a2f125 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/RollAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/RollAnimator.java @@ -1,11 +1,11 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.Roll; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.Easing; import com.alrex.parcool.utilities.MathUtil; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/SlidingAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/SlidingAnimator.java index a9a25699..26f2b27d 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/SlidingAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/SlidingAnimator.java @@ -1,12 +1,12 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.Slide; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.utilities.Easing; import com.alrex.parcool.utilities.VectorUtil; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/SpeedVaultAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/SpeedVaultAnimator.java index 93fcddfa..e17f1c41 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/SpeedVaultAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/SpeedVaultAnimator.java @@ -5,6 +5,7 @@ import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.Vault; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.Easing; import com.alrex.parcool.utilities.EasingFunctions; @@ -13,8 +14,6 @@ import static com.alrex.parcool.utilities.MathUtil.lerp; -import com.alrex.parcool.api.compatibility.PlayerWrapper; - public class SpeedVaultAnimator extends Animator { @Override diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/TapAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/TapAnimator.java index d8167c5f..1b14069c 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/TapAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/TapAnimator.java @@ -1,11 +1,11 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.Tap; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.utilities.Easing; public class TapAnimator extends Animator { diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/VerticalWallRunAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/VerticalWallRunAnimator.java index d187fa01..69184e8e 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/VerticalWallRunAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/VerticalWallRunAnimator.java @@ -1,10 +1,10 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.utilities.Easing; public class VerticalWallRunAnimator extends Animator { diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/WallJumpAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/WallJumpAnimator.java index 3876d241..8bc0608f 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/WallJumpAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/WallJumpAnimator.java @@ -1,10 +1,10 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.utilities.Easing; import static java.lang.Math.toRadians; diff --git a/src/main/java/com/alrex/parcool/client/animation/impl/WallSlideAnimator.java b/src/main/java/com/alrex/parcool/client/animation/impl/WallSlideAnimator.java index 5a046a3e..b24be736 100644 --- a/src/main/java/com/alrex/parcool/client/animation/impl/WallSlideAnimator.java +++ b/src/main/java/com/alrex/parcool/client/animation/impl/WallSlideAnimator.java @@ -1,11 +1,11 @@ package com.alrex.parcool.client.animation.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.Animator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.action.impl.WallSlide; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.utilities.VectorUtil; public class WallSlideAnimator extends Animator { diff --git a/src/main/java/com/alrex/parcool/client/gui/SettingActionLimitationScreen.java b/src/main/java/com/alrex/parcool/client/gui/SettingActionLimitationScreen.java index 91dfaef1..3663148c 100644 --- a/src/main/java/com/alrex/parcool/client/gui/SettingActionLimitationScreen.java +++ b/src/main/java/com/alrex/parcool/client/gui/SettingActionLimitationScreen.java @@ -1,12 +1,12 @@ package com.alrex.parcool.client.gui; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.ActionList; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ActionInfo; import com.alrex.parcool.common.info.ClientSetting; import com.alrex.parcool.common.network.SyncClientInformationMessage; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.mojang.blaze3d.matrix.MatrixStack; import net.minecraft.client.gui.widget.button.CheckboxButton; diff --git a/src/main/java/com/alrex/parcool/client/gui/SettingBooleanConfigScreen.java b/src/main/java/com/alrex/parcool/client/gui/SettingBooleanConfigScreen.java index 6975d106..b10364db 100644 --- a/src/main/java/com/alrex/parcool/client/gui/SettingBooleanConfigScreen.java +++ b/src/main/java/com/alrex/parcool/client/gui/SettingBooleanConfigScreen.java @@ -1,10 +1,10 @@ package com.alrex.parcool.client.gui; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ActionInfo; import com.alrex.parcool.common.info.ClientSetting; import com.alrex.parcool.common.network.SyncClientInformationMessage; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.mojang.blaze3d.matrix.MatrixStack; import net.minecraft.client.gui.widget.button.CheckboxButton; diff --git a/src/main/java/com/alrex/parcool/client/gui/SettingEnumConfigScreen.java b/src/main/java/com/alrex/parcool/client/gui/SettingEnumConfigScreen.java index ca912126..7f7d73dd 100644 --- a/src/main/java/com/alrex/parcool/client/gui/SettingEnumConfigScreen.java +++ b/src/main/java/com/alrex/parcool/client/gui/SettingEnumConfigScreen.java @@ -1,10 +1,10 @@ package com.alrex.parcool.client.gui; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ActionInfo; import com.alrex.parcool.common.info.ClientSetting; import com.alrex.parcool.common.network.SyncClientInformationMessage; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.mojang.blaze3d.matrix.MatrixStack; import net.minecraft.client.gui.widget.button.Button; diff --git a/src/main/java/com/alrex/parcool/client/hud/impl/LightStaminaHUD.java b/src/main/java/com/alrex/parcool/client/hud/impl/LightStaminaHUD.java index 9396d03c..28ecc0df 100644 --- a/src/main/java/com/alrex/parcool/client/hud/impl/LightStaminaHUD.java +++ b/src/main/java/com/alrex/parcool/client/hud/impl/LightStaminaHUD.java @@ -1,10 +1,10 @@ package com.alrex.parcool.client.hud.impl; import com.alrex.parcool.api.Effects; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.MathUtil; import com.mojang.blaze3d.matrix.MatrixStack; diff --git a/src/main/java/com/alrex/parcool/client/hud/impl/StaminaHUD.java b/src/main/java/com/alrex/parcool/client/hud/impl/StaminaHUD.java index 6a241269..45733bae 100644 --- a/src/main/java/com/alrex/parcool/client/hud/impl/StaminaHUD.java +++ b/src/main/java/com/alrex/parcool/client/hud/impl/StaminaHUD.java @@ -1,11 +1,11 @@ package com.alrex.parcool.client.hud.impl; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.client.hud.Position; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.MathUtil; import com.mojang.blaze3d.matrix.MatrixStack; diff --git a/src/main/java/com/alrex/parcool/client/hud/impl/StaminaHUDController.java b/src/main/java/com/alrex/parcool/client/hud/impl/StaminaHUDController.java index d479902b..0b3c7754 100644 --- a/src/main/java/com/alrex/parcool/client/hud/impl/StaminaHUDController.java +++ b/src/main/java/com/alrex/parcool/client/hud/impl/StaminaHUDController.java @@ -1,9 +1,9 @@ package com.alrex.parcool.client.hud.impl; import com.alrex.parcool.api.client.gui.ParCoolHUDEvent; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.stamina.Stamina; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.mojang.blaze3d.matrix.MatrixStack; import net.minecraftforge.api.distmarker.Dist; diff --git a/src/main/java/com/alrex/parcool/client/renderer/entity/ZiplineRopeRenderer.java b/src/main/java/com/alrex/parcool/client/renderer/entity/ZiplineRopeRenderer.java index 09ec45ac..6cb70d3c 100644 --- a/src/main/java/com/alrex/parcool/client/renderer/entity/ZiplineRopeRenderer.java +++ b/src/main/java/com/alrex/parcool/client/renderer/entity/ZiplineRopeRenderer.java @@ -1,11 +1,11 @@ package com.alrex.parcool.client.renderer.entity; -import com.alrex.parcool.api.compatibility.AxisWrapper; -import com.alrex.parcool.api.compatibility.EntityWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.renderer.RenderTypes; import com.alrex.parcool.common.entity.zipline.ZiplineRopeEntity; import com.alrex.parcool.common.zipline.Zipline; +import com.alrex.parcool.compatibility.AxisWrapper; +import com.alrex.parcool.compatibility.EntityWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import com.mojang.blaze3d.matrix.MatrixStack; import com.mojang.blaze3d.vertex.IVertexBuilder; diff --git a/src/main/java/com/alrex/parcool/common/action/Action.java b/src/main/java/com/alrex/parcool/common/action/Action.java index 11463ee3..11c6bb68 100644 --- a/src/main/java/com/alrex/parcool/common/action/Action.java +++ b/src/main/java/com/alrex/parcool/common/action/Action.java @@ -1,9 +1,10 @@ package com.alrex.parcool.common.action; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; + import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; import net.minecraftforge.event.TickEvent; diff --git a/src/main/java/com/alrex/parcool/common/action/ActionProcessor.java b/src/main/java/com/alrex/parcool/common/action/ActionProcessor.java index 4704d995..06064983 100644 --- a/src/main/java/com/alrex/parcool/common/action/ActionProcessor.java +++ b/src/main/java/com/alrex/parcool/common/action/ActionProcessor.java @@ -1,15 +1,16 @@ package com.alrex.parcool.common.action; import com.alrex.parcool.ParCool; -import com.alrex.parcool.api.compatibility.AbstractClientPlayerWrapper; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; -import com.alrex.parcool.api.compatibility.EventBusWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.network.SyncActionStateMessage; import com.alrex.parcool.common.network.SyncStaminaMessage; +import com.alrex.parcool.compatibility.AbstractClientPlayerWrapper; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.compatibility.EventBusWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; + import net.minecraft.util.text.TextFormatting; import net.minecraft.util.text.TranslationTextComponent; import net.minecraftforge.api.distmarker.Dist; diff --git a/src/main/java/com/alrex/parcool/common/action/AdditionalProperties.java b/src/main/java/com/alrex/parcool/common/action/AdditionalProperties.java index 2fef2c8b..4d2d774c 100644 --- a/src/main/java/com/alrex/parcool/common/action/AdditionalProperties.java +++ b/src/main/java/com/alrex/parcool/common/action/AdditionalProperties.java @@ -1,7 +1,7 @@ package com.alrex.parcool.common.action; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; public class AdditionalProperties { private int sprintingTick = 0; diff --git a/src/main/java/com/alrex/parcool/common/action/BehaviorEnforcer.java b/src/main/java/com/alrex/parcool/common/action/BehaviorEnforcer.java index 26e41b40..8a2441bd 100644 --- a/src/main/java/com/alrex/parcool/common/action/BehaviorEnforcer.java +++ b/src/main/java/com/alrex/parcool/common/action/BehaviorEnforcer.java @@ -6,7 +6,7 @@ import javax.annotation.Nullable; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import java.util.TreeMap; import java.util.function.Supplier; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/BreakfallReady.java b/src/main/java/com/alrex/parcool/common/action/impl/BreakfallReady.java index b0d8e966..6d5e61d1 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/BreakfallReady.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/BreakfallReady.java @@ -1,13 +1,13 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.StaminaConsumeTiming; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.particles.ParticleTypes; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java b/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java index 5dd5df13..96b982bc 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java @@ -1,10 +1,6 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; -import com.alrex.parcool.api.compatibility.LevelWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.CatLeapAnimator; import com.alrex.parcool.client.input.KeyRecorder; import com.alrex.parcool.common.action.Action; @@ -12,6 +8,10 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.block.BlockRenderType; import net.minecraft.block.BlockState; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/ChargeJump.java b/src/main/java/com/alrex/parcool/common/action/impl/ChargeJump.java index d5821ce6..3bbba4bd 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/ChargeJump.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/ChargeJump.java @@ -1,10 +1,6 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; -import com.alrex.parcool.api.compatibility.EventBusWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.ChargeJumpAnimator; import com.alrex.parcool.client.animation.impl.JumpChargingAnimator; import com.alrex.parcool.client.input.KeyRecorder; @@ -13,6 +9,10 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.compatibility.EventBusWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.VectorUtil; import java.nio.ByteBuffer; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/ClimbPoles.java b/src/main/java/com/alrex/parcool/common/action/impl/ClimbPoles.java index b64beb99..58b6bc2e 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/ClimbPoles.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/ClimbPoles.java @@ -1,10 +1,10 @@ package com.alrex.parcool.common.action.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.StaminaConsumeTiming; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import java.nio.ByteBuffer; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/ClimbUp.java b/src/main/java/com/alrex/parcool/common/action/impl/ClimbUp.java index dc397940..486844d0 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/ClimbUp.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/ClimbUp.java @@ -1,8 +1,6 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.ClimbUpAnimator; import com.alrex.parcool.client.input.KeyRecorder; import com.alrex.parcool.common.action.Action; @@ -10,6 +8,8 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/ClingToCliff.java b/src/main/java/com/alrex/parcool/common/action/impl/ClingToCliff.java index fc22cbe8..de945432 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/ClingToCliff.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/ClingToCliff.java @@ -1,8 +1,6 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.ClingToCliffAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -12,6 +10,8 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.VectorUtil; import com.alrex.parcool.utilities.WorldUtil; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Crawl.java b/src/main/java/com/alrex/parcool/common/action/impl/Crawl.java index 9efac3a1..d9142994 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Crawl.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Crawl.java @@ -1,6 +1,5 @@ package com.alrex.parcool.common.action.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.CrawlAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -9,6 +8,7 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.entity.Pose; import net.minecraftforge.api.distmarker.Dist; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Dive.java b/src/main/java/com/alrex/parcool/common/action/impl/Dive.java index e353620f..bfef47f8 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Dive.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Dive.java @@ -1,6 +1,5 @@ package com.alrex.parcool.common.action.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.DiveAnimationHostAnimator; import com.alrex.parcool.client.animation.impl.DiveIntoWaterAnimator; import com.alrex.parcool.client.input.KeyRecorder; @@ -9,6 +8,7 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.utilities.BufferUtil; import com.alrex.parcool.utilities.WorldUtil; import net.minecraft.util.math.MathHelper; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Dodge.java b/src/main/java/com/alrex/parcool/common/action/impl/Dodge.java index 0a029803..b72d4d91 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Dodge.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Dodge.java @@ -1,9 +1,6 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.DodgeAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -14,6 +11,9 @@ import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ActionInfo; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.extern.AdditionalMods; import com.alrex.parcool.utilities.VectorUtil; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/FastRun.java b/src/main/java/com/alrex/parcool/common/action/impl/FastRun.java index ed3d3b57..4c5ae30a 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/FastRun.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/FastRun.java @@ -1,6 +1,5 @@ package com.alrex.parcool.common.action.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.FastRunningAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -11,6 +10,7 @@ import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ActionInfo; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.entity.ai.attributes.AttributeModifier; import net.minecraft.entity.ai.attributes.Attributes; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/FastSwim.java b/src/main/java/com/alrex/parcool/common/action/impl/FastSwim.java index bf4c2150..715a4f13 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/FastSwim.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/FastSwim.java @@ -1,6 +1,5 @@ package com.alrex.parcool.common.action.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.FastSwimAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -10,6 +9,7 @@ import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ActionInfo; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.entity.ai.attributes.AttributeModifier; import net.minecraft.entity.ai.attributes.ModifiableAttributeInstance; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Flipping.java b/src/main/java/com/alrex/parcool/common/action/impl/Flipping.java index 928ba0bb..d9b7e3c4 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Flipping.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Flipping.java @@ -1,6 +1,5 @@ package com.alrex.parcool.common.action.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.FlippingAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -9,6 +8,7 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/HangDown.java b/src/main/java/com/alrex/parcool/common/action/impl/HangDown.java index e330690a..58352044 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/HangDown.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/HangDown.java @@ -1,8 +1,6 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.HangAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; @@ -11,6 +9,8 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.VectorUtil; import com.alrex.parcool.utilities.WorldUtil; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java b/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java index 15e2955b..6eacccf6 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java @@ -1,8 +1,5 @@ package com.alrex.parcool.common.action.impl; -import com.alrex.parcool.api.compatibility.LevelWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.RenderBehaviorEnforcer; import com.alrex.parcool.client.animation.impl.HideInBlockAnimator; import com.alrex.parcool.client.input.KeyBindings; @@ -12,6 +9,9 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.utilities.BufferUtil; import com.alrex.parcool.utilities.WorldUtil; import net.minecraft.client.Minecraft; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java b/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java index e4ceb79d..29ebfb5d 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java @@ -1,9 +1,6 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.compatibility.LevelWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.HorizontalWallRunAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; @@ -12,6 +9,9 @@ import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ActionInfo; +import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.BufferUtil; import com.alrex.parcool.utilities.VectorUtil; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/JumpFromBar.java b/src/main/java/com/alrex/parcool/common/action/impl/JumpFromBar.java index 6ed22b37..385aa616 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/JumpFromBar.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/JumpFromBar.java @@ -1,7 +1,6 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.JumpFromBarAnimator; import com.alrex.parcool.client.input.KeyRecorder; import com.alrex.parcool.common.action.Action; @@ -9,6 +8,7 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.EntityUtil; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/QuickTurn.java b/src/main/java/com/alrex/parcool/common/action/impl/QuickTurn.java index 6bd02817..a914b944 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/QuickTurn.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/QuickTurn.java @@ -1,12 +1,12 @@ package com.alrex.parcool.common.action.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.input.KeyRecorder; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.StaminaConsumeTiming; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.utilities.VectorUtil; import net.minecraftforge.event.TickEvent; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/RideZipline.java b/src/main/java/com/alrex/parcool/common/action/impl/RideZipline.java index 442d25ea..b6485c1c 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/RideZipline.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/RideZipline.java @@ -1,7 +1,5 @@ package com.alrex.parcool.common.action.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.RideZiplineAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.client.input.KeyRecorder; @@ -13,6 +11,8 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.entity.zipline.ZiplineRopeEntity; import com.alrex.parcool.common.zipline.Zipline; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.utilities.BufferUtil; import com.alrex.parcool.utilities.VectorUtil; import net.minecraft.util.math.MathHelper; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Roll.java b/src/main/java/com/alrex/parcool/common/action/impl/Roll.java index f8582fd3..6f2bec4d 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Roll.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Roll.java @@ -1,8 +1,5 @@ package com.alrex.parcool.common.action.impl; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.RollAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; @@ -11,6 +8,9 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.VectorUtil; import net.minecraftforge.api.distmarker.Dist; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/SkyDive.java b/src/main/java/com/alrex/parcool/common/action/impl/SkyDive.java index 9818e002..823d16ff 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/SkyDive.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/SkyDive.java @@ -1,13 +1,13 @@ package com.alrex.parcool.common.action.impl; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.input.KeyRecorder; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.StaminaConsumeTiming; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.utilities.VectorUtil; import net.minecraftforge.event.TickEvent; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Slide.java b/src/main/java/com/alrex/parcool/common/action/impl/Slide.java index f05533b8..aa3c872a 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Slide.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Slide.java @@ -1,9 +1,6 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.compatibility.LevelWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.CrawlAnimator; import com.alrex.parcool.client.animation.impl.SlidingAnimator; import com.alrex.parcool.client.input.KeyRecorder; @@ -13,6 +10,9 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.block.BlockRenderType; import net.minecraft.block.BlockState; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Tap.java b/src/main/java/com/alrex/parcool/common/action/impl/Tap.java index 41f73b3e..f4474a60 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Tap.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Tap.java @@ -1,6 +1,5 @@ package com.alrex.parcool.common.action.impl; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.impl.TapAnimator; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.BehaviorEnforcer; @@ -8,6 +7,7 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; import java.nio.ByteBuffer; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Vault.java b/src/main/java/com/alrex/parcool/common/action/impl/Vault.java index fbc58153..e617308e 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Vault.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Vault.java @@ -1,8 +1,6 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.KongVaultAnimator; import com.alrex.parcool.client.animation.impl.SpeedVaultAnimator; import com.alrex.parcool.client.input.KeyBindings; @@ -11,6 +9,8 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.WorldUtil; import net.minecraftforge.api.distmarker.Dist; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java b/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java index 716d1d96..ec0c131d 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java @@ -1,9 +1,6 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.compatibility.LevelWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.VerticalWallRunAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; @@ -11,6 +8,9 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.VectorUtil; import com.alrex.parcool.utilities.WorldUtil; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java b/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java index 3d1eae1c..a39dd74b 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java @@ -1,9 +1,6 @@ package com.alrex.parcool.common.action.impl; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.compatibility.LevelWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.BackwardWallJumpAnimator; import com.alrex.parcool.client.animation.impl.WallJumpAnimator; import com.alrex.parcool.client.input.KeyRecorder; @@ -12,6 +9,9 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.WorldUtil; import net.minecraft.block.BlockRenderType; diff --git a/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java b/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java index 66b6dfb8..e0bbdb6f 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java @@ -1,8 +1,5 @@ package com.alrex.parcool.common.action.impl; -import com.alrex.parcool.api.compatibility.LevelWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.client.animation.impl.WallSlideAnimator; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.Action; @@ -11,6 +8,9 @@ import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.damage.DamageSources; +import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.WorldUtil; import net.minecraft.block.BlockRenderType; diff --git a/src/main/java/com/alrex/parcool/common/block/zipline/IronZiplineHookBlock.java b/src/main/java/com/alrex/parcool/common/block/zipline/IronZiplineHookBlock.java index 0de23ad1..6e875238 100644 --- a/src/main/java/com/alrex/parcool/common/block/zipline/IronZiplineHookBlock.java +++ b/src/main/java/com/alrex/parcool/common/block/zipline/IronZiplineHookBlock.java @@ -1,8 +1,9 @@ package com.alrex.parcool.common.block.zipline; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.block.BlockStateProperties; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; + import net.minecraft.block.Block; import net.minecraft.block.BlockState; import net.minecraft.item.BlockItemUseContext; diff --git a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java index 3286d69d..2152a881 100644 --- a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java +++ b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java @@ -1,13 +1,14 @@ package com.alrex.parcool.common.block.zipline; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.compatibility.BlockEntityWrapper; -import com.alrex.parcool.api.compatibility.ContainersWrapper; -import com.alrex.parcool.api.compatibility.InteractionResultWrapper; -import com.alrex.parcool.api.compatibility.LevelWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.block.TileEntities; +import com.alrex.parcool.compatibility.BlockEntityWrapper; +import com.alrex.parcool.compatibility.ContainersWrapper; +import com.alrex.parcool.compatibility.InteractionResultWrapper; +import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; + import net.minecraft.block.Block; import net.minecraft.block.BlockState; import net.minecraft.block.Blocks; diff --git a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookTileEntity.java b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookTileEntity.java index 839a9b76..8e8f29a7 100644 --- a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookTileEntity.java +++ b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookTileEntity.java @@ -1,10 +1,11 @@ package com.alrex.parcool.common.block.zipline; -import com.alrex.parcool.api.compatibility.LevelWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.entity.zipline.ZiplineRopeEntity; import com.alrex.parcool.common.item.Items; import com.alrex.parcool.common.item.zipline.ZiplineRopeItem; +import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; + import net.minecraft.block.Block; import net.minecraft.block.BlockState; import net.minecraft.item.ItemStack; diff --git a/src/main/java/com/alrex/parcool/common/capability/Animation.java b/src/main/java/com/alrex/parcool/common/capability/Animation.java index 4b61158e..2ff9c1b1 100644 --- a/src/main/java/com/alrex/parcool/common/capability/Animation.java +++ b/src/main/java/com/alrex/parcool/common/capability/Animation.java @@ -1,8 +1,5 @@ package com.alrex.parcool.common.capability; -import com.alrex.parcool.api.compatibility.AbstractClientPlayerWrapper; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.api.unstable.animation.AnimationOption; import com.alrex.parcool.api.unstable.animation.AnimationPart; import com.alrex.parcool.api.unstable.animation.ParCoolAnimationInfoEvent; @@ -11,6 +8,9 @@ import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.capability.capabilities.Capabilities; +import com.alrex.parcool.compatibility.AbstractClientPlayerWrapper; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.client.Minecraft; import net.minecraftforge.api.distmarker.Dist; diff --git a/src/main/java/com/alrex/parcool/common/capability/IStamina.java b/src/main/java/com/alrex/parcool/common/capability/IStamina.java index 49a58a7c..5bf7e91e 100644 --- a/src/main/java/com/alrex/parcool/common/capability/IStamina.java +++ b/src/main/java/com/alrex/parcool/common/capability/IStamina.java @@ -1,10 +1,11 @@ package com.alrex.parcool.common.capability; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.capabilities.Capabilities; import com.alrex.parcool.common.capability.stamina.HungerStamina; import com.alrex.parcool.common.capability.stamina.Stamina; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.ServerPlayerWrapper; + import javax.annotation.Nullable; import java.util.function.BiConsumer; import java.util.function.Function; diff --git a/src/main/java/com/alrex/parcool/common/capability/Parkourability.java b/src/main/java/com/alrex/parcool/common/capability/Parkourability.java index 9a59532e..dca07972 100644 --- a/src/main/java/com/alrex/parcool/common/capability/Parkourability.java +++ b/src/main/java/com/alrex/parcool/common/capability/Parkourability.java @@ -1,7 +1,5 @@ package com.alrex.parcool.common.capability; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.ActionList; import com.alrex.parcool.common.action.AdditionalProperties; @@ -11,6 +9,9 @@ import com.alrex.parcool.common.info.ClientSetting; import com.alrex.parcool.common.info.ServerLimitation; import com.alrex.parcool.common.network.SyncClientInformationMessage; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; + import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; diff --git a/src/main/java/com/alrex/parcool/common/capability/stamina/HungerStamina.java b/src/main/java/com/alrex/parcool/common/capability/stamina/HungerStamina.java index 04adde5c..acfc8ab3 100644 --- a/src/main/java/com/alrex/parcool/common/capability/stamina/HungerStamina.java +++ b/src/main/java/com/alrex/parcool/common/capability/stamina/HungerStamina.java @@ -1,10 +1,10 @@ package com.alrex.parcool.common.capability.stamina; import com.alrex.parcool.api.Effects; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.ServerPlayerWrapper; public class HungerStamina implements IStamina { private final PlayerWrapper player; diff --git a/src/main/java/com/alrex/parcool/common/capability/stamina/OtherStamina.java b/src/main/java/com/alrex/parcool/common/capability/stamina/OtherStamina.java index c3b4f54c..93684791 100644 --- a/src/main/java/com/alrex/parcool/common/capability/stamina/OtherStamina.java +++ b/src/main/java/com/alrex/parcool/common/capability/stamina/OtherStamina.java @@ -1,8 +1,9 @@ package com.alrex.parcool.common.capability.stamina; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.IStamina; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.ServerPlayerWrapper; + import net.minecraft.entity.ai.attributes.AttributeModifier; import net.minecraft.entity.ai.attributes.Attributes; import net.minecraft.entity.ai.attributes.ModifiableAttributeInstance; diff --git a/src/main/java/com/alrex/parcool/common/capability/stamina/Stamina.java b/src/main/java/com/alrex/parcool/common/capability/stamina/Stamina.java index d935309d..f3021306 100644 --- a/src/main/java/com/alrex/parcool/common/capability/stamina/Stamina.java +++ b/src/main/java/com/alrex/parcool/common/capability/stamina/Stamina.java @@ -2,9 +2,10 @@ import com.alrex.parcool.api.Attributes; import com.alrex.parcool.api.Effects; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; + import net.minecraft.entity.ai.attributes.ModifiableAttributeInstance; import javax.annotation.Nullable; diff --git a/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java b/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java index c2e4f6c5..ae67fba8 100644 --- a/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java +++ b/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java @@ -1,12 +1,13 @@ package com.alrex.parcool.common.entity.zipline; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.block.zipline.ZiplineHookTileEntity; import com.alrex.parcool.common.block.zipline.ZiplineInfo; import com.alrex.parcool.common.item.zipline.ZiplineRopeItem; import com.alrex.parcool.common.zipline.Zipline; import com.alrex.parcool.common.zipline.ZiplineType; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; + import net.minecraft.entity.Entity; import net.minecraft.entity.EntitySize; import net.minecraft.entity.EntityType; diff --git a/src/main/java/com/alrex/parcool/common/handlers/AttachCapabilityHandler.java b/src/main/java/com/alrex/parcool/common/handlers/AttachCapabilityHandler.java index dd1aad5d..3b37beca 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/AttachCapabilityHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/AttachCapabilityHandler.java @@ -1,11 +1,11 @@ package com.alrex.parcool.common.handlers; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.capability.capabilities.Capabilities; import com.alrex.parcool.common.capability.stamina.OtherStamina; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.entity.Entity; import net.minecraft.nbt.CompoundNBT; diff --git a/src/main/java/com/alrex/parcool/common/handlers/EnableOrDisableParCoolHandler.java b/src/main/java/com/alrex/parcool/common/handlers/EnableOrDisableParCoolHandler.java index bf9b036a..61400842 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/EnableOrDisableParCoolHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/EnableOrDisableParCoolHandler.java @@ -2,11 +2,11 @@ import com.alrex.parcool.ParCool; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ClientSetting; import com.alrex.parcool.common.network.SyncClientInformationMessage; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.util.text.TranslationTextComponent; import net.minecraftforge.api.distmarker.Dist; diff --git a/src/main/java/com/alrex/parcool/common/handlers/InputHandler.java b/src/main/java/com/alrex/parcool/common/handlers/InputHandler.java index 2c1d6af1..ef85e864 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/InputHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/InputHandler.java @@ -1,12 +1,13 @@ package com.alrex.parcool.common.handlers; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.client.input.KeyBindings; import com.alrex.parcool.common.action.impl.ClingToCliff; import com.alrex.parcool.common.action.impl.HideInBlock; import com.alrex.parcool.common.action.impl.RideZipline; import com.alrex.parcool.common.action.impl.WallSlide; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; + import net.minecraftforge.client.event.InputEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; diff --git a/src/main/java/com/alrex/parcool/common/handlers/LoginLogoutHandler.java b/src/main/java/com/alrex/parcool/common/handlers/LoginLogoutHandler.java index 6e6e17c7..78127c98 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/LoginLogoutHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/LoginLogoutHandler.java @@ -1,8 +1,8 @@ package com.alrex.parcool.common.handlers; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.ServerPlayerWrapper; import com.alrex.parcool.server.limitation.Limitations; import net.minecraftforge.event.entity.player.PlayerEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; diff --git a/src/main/java/com/alrex/parcool/common/handlers/OpenSettingsParCoolHandler.java b/src/main/java/com/alrex/parcool/common/handlers/OpenSettingsParCoolHandler.java index 97967eef..088dec3c 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/OpenSettingsParCoolHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/OpenSettingsParCoolHandler.java @@ -1,9 +1,9 @@ package com.alrex.parcool.common.handlers; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.client.gui.SettingActionLimitationScreen; import com.alrex.parcool.client.input.KeyRecorder; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.client.Minecraft; import net.minecraft.util.text.StringTextComponent; diff --git a/src/main/java/com/alrex/parcool/common/handlers/PlayerCloneHandler.java b/src/main/java/com/alrex/parcool/common/handlers/PlayerCloneHandler.java index 25a16fdc..95047a95 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/PlayerCloneHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/PlayerCloneHandler.java @@ -1,8 +1,9 @@ package com.alrex.parcool.common.handlers; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.ServerPlayerWrapper; + import net.minecraftforge.event.entity.player.PlayerEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; diff --git a/src/main/java/com/alrex/parcool/common/handlers/PlayerDamageHandler.java b/src/main/java/com/alrex/parcool/common/handlers/PlayerDamageHandler.java index 5d7e38cd..97a8b5df 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/PlayerDamageHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/PlayerDamageHandler.java @@ -1,10 +1,10 @@ package com.alrex.parcool.common.handlers; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.action.impl.*; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.network.StartBreakfallMessage; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.ServerPlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.entity.LivingEntity; import net.minecraftforge.event.entity.living.LivingAttackEvent; diff --git a/src/main/java/com/alrex/parcool/common/handlers/PlayerJoinHandler.java b/src/main/java/com/alrex/parcool/common/handlers/PlayerJoinHandler.java index df4e68ab..4ceae77e 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/PlayerJoinHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/PlayerJoinHandler.java @@ -1,10 +1,11 @@ package com.alrex.parcool.common.handlers; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ClientSetting; import com.alrex.parcool.common.network.SyncClientInformationMessage; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; + import net.minecraft.entity.Entity; import net.minecraftforge.event.entity.EntityJoinWorldEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; diff --git a/src/main/java/com/alrex/parcool/common/handlers/PlayerJumpHandler.java b/src/main/java/com/alrex/parcool/common/handlers/PlayerJumpHandler.java index 3ea492a8..d5e137ed 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/PlayerJumpHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/PlayerJumpHandler.java @@ -1,11 +1,12 @@ package com.alrex.parcool.common.handlers; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.impl.ChargeJump; import com.alrex.parcool.common.action.impl.Dive; import com.alrex.parcool.common.action.impl.Flipping; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; + import net.minecraftforge.event.entity.living.LivingEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; diff --git a/src/main/java/com/alrex/parcool/common/handlers/PlayerVisibilityHandler.java b/src/main/java/com/alrex/parcool/common/handlers/PlayerVisibilityHandler.java index da557711..75b41b40 100644 --- a/src/main/java/com/alrex/parcool/common/handlers/PlayerVisibilityHandler.java +++ b/src/main/java/com/alrex/parcool/common/handlers/PlayerVisibilityHandler.java @@ -1,8 +1,9 @@ package com.alrex.parcool.common.handlers; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.impl.HideInBlock; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; + import net.minecraft.entity.Entity; import net.minecraftforge.event.entity.living.LivingEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; diff --git a/src/main/java/com/alrex/parcool/common/info/ServerLimitation.java b/src/main/java/com/alrex/parcool/common/info/ServerLimitation.java index b56f1261..e2674639 100644 --- a/src/main/java/com/alrex/parcool/common/info/ServerLimitation.java +++ b/src/main/java/com/alrex/parcool/common/info/ServerLimitation.java @@ -1,8 +1,8 @@ package com.alrex.parcool.common.info; -import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.ActionList; +import com.alrex.parcool.compatibility.ServerPlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.server.limitation.Limitation; import com.alrex.parcool.server.limitation.Limitations; diff --git a/src/main/java/com/alrex/parcool/common/item/zipline/ZiplineRopeItem.java b/src/main/java/com/alrex/parcool/common/item/zipline/ZiplineRopeItem.java index fd081c6f..1925a53b 100644 --- a/src/main/java/com/alrex/parcool/common/item/zipline/ZiplineRopeItem.java +++ b/src/main/java/com/alrex/parcool/common/item/zipline/ZiplineRopeItem.java @@ -1,12 +1,13 @@ package com.alrex.parcool.common.item.zipline; import com.alrex.parcool.api.SoundEvents; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.block.zipline.ZiplineHookBlock; import com.alrex.parcool.common.block.zipline.ZiplineHookTileEntity; import com.alrex.parcool.common.block.zipline.ZiplineInfo; import com.alrex.parcool.common.zipline.Zipline; import com.alrex.parcool.common.zipline.ZiplineType; +import com.alrex.parcool.compatibility.PlayerWrapper; + import net.minecraft.client.renderer.color.IItemColor; import net.minecraft.client.util.ITooltipFlag; import net.minecraft.item.Item; diff --git a/src/main/java/com/alrex/parcool/common/network/StartBreakfallMessage.java b/src/main/java/com/alrex/parcool/common/network/StartBreakfallMessage.java index fcecc7c8..bfe0b8d4 100644 --- a/src/main/java/com/alrex/parcool/common/network/StartBreakfallMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/StartBreakfallMessage.java @@ -1,12 +1,13 @@ package com.alrex.parcool.common.network; -import com.alrex.parcool.api.compatibility.ChannelInstanceWrapper; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.action.impl.BreakfallReady; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.ChannelInstanceWrapper; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.ServerPlayerWrapper; + import net.minecraft.network.PacketBuffer; import net.minecraft.network.PacketDirection; import net.minecraftforge.api.distmarker.Dist; diff --git a/src/main/java/com/alrex/parcool/common/network/SyncActionStateMessage.java b/src/main/java/com/alrex/parcool/common/network/SyncActionStateMessage.java index 21e8e14b..be427a0c 100644 --- a/src/main/java/com/alrex/parcool/common/network/SyncActionStateMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/SyncActionStateMessage.java @@ -1,11 +1,12 @@ package com.alrex.parcool.common.network; import com.alrex.parcool.ParCool; -import com.alrex.parcool.api.compatibility.EventBusWrapper; -import com.alrex.parcool.api.compatibility.LevelWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.EventBusWrapper; +import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; + import net.minecraft.network.PacketBuffer; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; diff --git a/src/main/java/com/alrex/parcool/common/network/SyncClientInformationMessage.java b/src/main/java/com/alrex/parcool/common/network/SyncClientInformationMessage.java index ed45016e..d00a103a 100644 --- a/src/main/java/com/alrex/parcool/common/network/SyncClientInformationMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/SyncClientInformationMessage.java @@ -1,12 +1,12 @@ package com.alrex.parcool.common.network; import com.alrex.parcool.ParCool; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; -import com.alrex.parcool.api.compatibility.MinecraftServerWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ClientSetting; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.compatibility.MinecraftServerWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.ServerPlayerWrapper; import com.alrex.parcool.server.limitation.Limitations; import net.minecraft.network.PacketBuffer; import net.minecraftforge.api.distmarker.Dist; diff --git a/src/main/java/com/alrex/parcool/common/network/SyncServerInfoMessage.java b/src/main/java/com/alrex/parcool/common/network/SyncServerInfoMessage.java index 9997894f..3cb6326f 100644 --- a/src/main/java/com/alrex/parcool/common/network/SyncServerInfoMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/SyncServerInfoMessage.java @@ -1,13 +1,14 @@ package com.alrex.parcool.common.network; import com.alrex.parcool.ParCool; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; -import com.alrex.parcool.api.compatibility.PlayerPacketDistributor; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ServerLimitation; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.compatibility.PlayerPacketDistributor; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.ServerPlayerWrapper; + import net.minecraft.network.PacketBuffer; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; diff --git a/src/main/java/com/alrex/parcool/common/network/SyncStaminaMessage.java b/src/main/java/com/alrex/parcool/common/network/SyncStaminaMessage.java index f891df48..2a4e93cf 100644 --- a/src/main/java/com/alrex/parcool/common/network/SyncStaminaMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/SyncStaminaMessage.java @@ -1,11 +1,12 @@ package com.alrex.parcool.common.network; import com.alrex.parcool.ParCool; -import com.alrex.parcool.api.compatibility.LevelWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.stamina.OtherStamina; +import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.ServerPlayerWrapper; + import net.minecraft.network.PacketBuffer; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; diff --git a/src/main/java/com/alrex/parcool/common/zipline/Zipline.java b/src/main/java/com/alrex/parcool/common/zipline/Zipline.java index 0cfc3734..f336b08d 100644 --- a/src/main/java/com/alrex/parcool/common/zipline/Zipline.java +++ b/src/main/java/com/alrex/parcool/common/zipline/Zipline.java @@ -1,9 +1,10 @@ package com.alrex.parcool.common.zipline; -import com.alrex.parcool.api.compatibility.LevelWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.entity.zipline.ZiplineRopeEntity; +import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; + import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; diff --git a/src/main/java/com/alrex/parcool/common/zipline/ZiplineType.java b/src/main/java/com/alrex/parcool/common/zipline/ZiplineType.java index 3130b03a..6ac91f98 100644 --- a/src/main/java/com/alrex/parcool/common/zipline/ZiplineType.java +++ b/src/main/java/com/alrex/parcool/common/zipline/ZiplineType.java @@ -1,8 +1,9 @@ package com.alrex.parcool.common.zipline; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.zipline.impl.GeneralQuadraticCurveZipline; import com.alrex.parcool.common.zipline.impl.StraightZipline; +import com.alrex.parcool.compatibility.Vec3Wrapper; + import net.minecraft.util.text.ITextComponent; import net.minecraft.util.text.TranslationTextComponent; diff --git a/src/main/java/com/alrex/parcool/common/zipline/impl/GeneralQuadraticCurveZipline.java b/src/main/java/com/alrex/parcool/common/zipline/impl/GeneralQuadraticCurveZipline.java index 99d09355..cb4367a3 100644 --- a/src/main/java/com/alrex/parcool/common/zipline/impl/GeneralQuadraticCurveZipline.java +++ b/src/main/java/com/alrex/parcool/common/zipline/impl/GeneralQuadraticCurveZipline.java @@ -1,7 +1,8 @@ package com.alrex.parcool.common.zipline.impl; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.zipline.Zipline; +import com.alrex.parcool.compatibility.Vec3Wrapper; + import net.minecraft.util.math.AxisAlignedBB; public class GeneralQuadraticCurveZipline extends Zipline { diff --git a/src/main/java/com/alrex/parcool/common/zipline/impl/QuadraticCurveZipline.java b/src/main/java/com/alrex/parcool/common/zipline/impl/QuadraticCurveZipline.java index ec81ec01..f72e9d76 100644 --- a/src/main/java/com/alrex/parcool/common/zipline/impl/QuadraticCurveZipline.java +++ b/src/main/java/com/alrex/parcool/common/zipline/impl/QuadraticCurveZipline.java @@ -1,7 +1,8 @@ package com.alrex.parcool.common.zipline.impl; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.zipline.Zipline; +import com.alrex.parcool.compatibility.Vec3Wrapper; + import net.minecraft.util.math.AxisAlignedBB; public class QuadraticCurveZipline extends Zipline { diff --git a/src/main/java/com/alrex/parcool/common/zipline/impl/StraightZipline.java b/src/main/java/com/alrex/parcool/common/zipline/impl/StraightZipline.java index 6fa72890..d4671a20 100644 --- a/src/main/java/com/alrex/parcool/common/zipline/impl/StraightZipline.java +++ b/src/main/java/com/alrex/parcool/common/zipline/impl/StraightZipline.java @@ -1,7 +1,8 @@ package com.alrex.parcool.common.zipline.impl; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.zipline.Zipline; +import com.alrex.parcool.compatibility.Vec3Wrapper; + import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.MathHelper; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/AbstractClientPlayerWrapper.java b/src/main/java/com/alrex/parcool/compatibility/AbstractClientPlayerWrapper.java similarity index 95% rename from src/main/java/com/alrex/parcool/api/compatibility/AbstractClientPlayerWrapper.java rename to src/main/java/com/alrex/parcool/compatibility/AbstractClientPlayerWrapper.java index c7ee9e50..0fcbb8f6 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/AbstractClientPlayerWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/AbstractClientPlayerWrapper.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import java.lang.ref.WeakReference; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/AxisWrapper.java b/src/main/java/com/alrex/parcool/compatibility/AxisWrapper.java similarity index 96% rename from src/main/java/com/alrex/parcool/api/compatibility/AxisWrapper.java rename to src/main/java/com/alrex/parcool/compatibility/AxisWrapper.java index 58e556f3..17fb5e76 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/AxisWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/AxisWrapper.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import net.minecraft.util.math.vector.Quaternion; import net.minecraft.util.math.vector.Vector3f; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/BlockEntityWrapper.java b/src/main/java/com/alrex/parcool/compatibility/BlockEntityWrapper.java similarity index 90% rename from src/main/java/com/alrex/parcool/api/compatibility/BlockEntityWrapper.java rename to src/main/java/com/alrex/parcool/compatibility/BlockEntityWrapper.java index 250a6bac..2d0cd3ee 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/BlockEntityWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/BlockEntityWrapper.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import net.minecraft.tileentity.TileEntity; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/ChannelInstanceWrapper.java b/src/main/java/com/alrex/parcool/compatibility/ChannelInstanceWrapper.java similarity index 89% rename from src/main/java/com/alrex/parcool/api/compatibility/ChannelInstanceWrapper.java rename to src/main/java/com/alrex/parcool/compatibility/ChannelInstanceWrapper.java index e82caf2e..dd4ded62 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/ChannelInstanceWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/ChannelInstanceWrapper.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import com.alrex.parcool.ParCool; import com.alrex.parcool.common.network.StartBreakfallMessage; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/ClientPlayerWrapper.java b/src/main/java/com/alrex/parcool/compatibility/ClientPlayerWrapper.java similarity index 98% rename from src/main/java/com/alrex/parcool/api/compatibility/ClientPlayerWrapper.java rename to src/main/java/com/alrex/parcool/compatibility/ClientPlayerWrapper.java index dd9b4a10..a4ab714c 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/ClientPlayerWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/ClientPlayerWrapper.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import java.lang.ref.WeakReference; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/ContainersWrapper.java b/src/main/java/com/alrex/parcool/compatibility/ContainersWrapper.java similarity index 91% rename from src/main/java/com/alrex/parcool/api/compatibility/ContainersWrapper.java rename to src/main/java/com/alrex/parcool/compatibility/ContainersWrapper.java index d4a3197e..c4b1524a 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/ContainersWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/ContainersWrapper.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import net.minecraft.inventory.InventoryHelper; import net.minecraft.item.ItemStack; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java b/src/main/java/com/alrex/parcool/compatibility/EntityWrapper.java similarity index 99% rename from src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java rename to src/main/java/com/alrex/parcool/compatibility/EntityWrapper.java index 185bfe6f..1f74ae33 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/EntityWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/EntityWrapper.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import java.lang.ref.WeakReference; import java.util.UUID; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/EventBusWrapper.java b/src/main/java/com/alrex/parcool/compatibility/EventBusWrapper.java similarity index 95% rename from src/main/java/com/alrex/parcool/api/compatibility/EventBusWrapper.java rename to src/main/java/com/alrex/parcool/compatibility/EventBusWrapper.java index c29cdd02..cbf6aa57 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/EventBusWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/EventBusWrapper.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import com.alrex.parcool.api.unstable.action.ParCoolActionEvent; import com.alrex.parcool.common.action.Action; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/InteractionResultWrapper.java b/src/main/java/com/alrex/parcool/compatibility/InteractionResultWrapper.java similarity index 89% rename from src/main/java/com/alrex/parcool/api/compatibility/InteractionResultWrapper.java rename to src/main/java/com/alrex/parcool/compatibility/InteractionResultWrapper.java index c13e1656..60d9368c 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/InteractionResultWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/InteractionResultWrapper.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import net.minecraft.util.ActionResultType; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/LevelWrapper.java b/src/main/java/com/alrex/parcool/compatibility/LevelWrapper.java similarity index 97% rename from src/main/java/com/alrex/parcool/api/compatibility/LevelWrapper.java rename to src/main/java/com/alrex/parcool/compatibility/LevelWrapper.java index eeab328d..25b26c1a 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/LevelWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/LevelWrapper.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import java.lang.ref.WeakReference; import java.util.List; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java b/src/main/java/com/alrex/parcool/compatibility/LivingEntityWrapper.java similarity index 98% rename from src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java rename to src/main/java/com/alrex/parcool/compatibility/LivingEntityWrapper.java index ce5bdcc7..42c415e6 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/LivingEntityWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/LivingEntityWrapper.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import java.lang.ref.WeakReference; import java.util.Random; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/MinecraftServerWrapper.java b/src/main/java/com/alrex/parcool/compatibility/MinecraftServerWrapper.java similarity index 98% rename from src/main/java/com/alrex/parcool/api/compatibility/MinecraftServerWrapper.java rename to src/main/java/com/alrex/parcool/compatibility/MinecraftServerWrapper.java index b1d6bfc0..5cd73314 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/MinecraftServerWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/MinecraftServerWrapper.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import java.util.Iterator; import java.util.UUID; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/PlayerPacketDistributor.java b/src/main/java/com/alrex/parcool/compatibility/PlayerPacketDistributor.java similarity index 90% rename from src/main/java/com/alrex/parcool/api/compatibility/PlayerPacketDistributor.java rename to src/main/java/com/alrex/parcool/compatibility/PlayerPacketDistributor.java index ff96aaa8..df1d79d4 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/PlayerPacketDistributor.java +++ b/src/main/java/com/alrex/parcool/compatibility/PlayerPacketDistributor.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import net.minecraft.entity.player.ServerPlayerEntity; import net.minecraftforge.fml.network.PacketDistributor; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java b/src/main/java/com/alrex/parcool/compatibility/PlayerWrapper.java similarity index 99% rename from src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java rename to src/main/java/com/alrex/parcool/compatibility/PlayerWrapper.java index ce96b5f9..7abf4b0f 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/PlayerWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/PlayerWrapper.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import java.lang.ref.WeakReference; import java.util.UUID; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/ServerPlayerWrapper.java b/src/main/java/com/alrex/parcool/compatibility/ServerPlayerWrapper.java similarity index 98% rename from src/main/java/com/alrex/parcool/api/compatibility/ServerPlayerWrapper.java rename to src/main/java/com/alrex/parcool/compatibility/ServerPlayerWrapper.java index f8b0da8c..f731a65f 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/ServerPlayerWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/ServerPlayerWrapper.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import java.util.function.Supplier; import javax.annotation.Nullable; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/Vec3Wrapper.java b/src/main/java/com/alrex/parcool/compatibility/Vec3Wrapper.java similarity index 97% rename from src/main/java/com/alrex/parcool/api/compatibility/Vec3Wrapper.java rename to src/main/java/com/alrex/parcool/compatibility/Vec3Wrapper.java index 1b23de97..bdcf9b22 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/Vec3Wrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/Vec3Wrapper.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import com.alrex.parcool.utilities.VectorUtil; import net.minecraft.util.math.vector.Vector3d; diff --git a/src/main/java/com/alrex/parcool/api/compatibility/WeakCache.java b/src/main/java/com/alrex/parcool/compatibility/WeakCache.java similarity index 93% rename from src/main/java/com/alrex/parcool/api/compatibility/WeakCache.java rename to src/main/java/com/alrex/parcool/compatibility/WeakCache.java index 896964d2..eb4d9278 100644 --- a/src/main/java/com/alrex/parcool/api/compatibility/WeakCache.java +++ b/src/main/java/com/alrex/parcool/compatibility/WeakCache.java @@ -1,4 +1,4 @@ -package com.alrex.parcool.api.compatibility; +package com.alrex.parcool.compatibility; import java.util.Map; import java.util.WeakHashMap; diff --git a/src/main/java/com/alrex/parcool/extern/betterthirdperson/BetterThirdPersonManager.java b/src/main/java/com/alrex/parcool/extern/betterthirdperson/BetterThirdPersonManager.java index 543bea14..85f4e24c 100644 --- a/src/main/java/com/alrex/parcool/extern/betterthirdperson/BetterThirdPersonManager.java +++ b/src/main/java/com/alrex/parcool/extern/betterthirdperson/BetterThirdPersonManager.java @@ -1,7 +1,7 @@ package com.alrex.parcool.extern.betterthirdperson; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.action.impl.Dodge; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; import com.alrex.parcool.extern.ModManager; import com.alrex.parcool.utilities.MathUtil; import io.socol.betterthirdperson.BetterThirdPerson; diff --git a/src/main/java/com/alrex/parcool/extern/shouldersurfing/ShoulderSurfingManager.java b/src/main/java/com/alrex/parcool/extern/shouldersurfing/ShoulderSurfingManager.java index 8c036444..593a6992 100644 --- a/src/main/java/com/alrex/parcool/extern/shouldersurfing/ShoulderSurfingManager.java +++ b/src/main/java/com/alrex/parcool/extern/shouldersurfing/ShoulderSurfingManager.java @@ -1,7 +1,7 @@ package com.alrex.parcool.extern.shouldersurfing; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.action.impl.Dodge; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; import com.alrex.parcool.extern.ModManager; import com.alrex.parcool.utilities.MathUtil; import com.github.exopandora.shouldersurfing.api.client.IShoulderSurfingCamera; diff --git a/src/main/java/com/alrex/parcool/mixin/client/ClientPlayerEntityMixin.java b/src/main/java/com/alrex/parcool/mixin/client/ClientPlayerEntityMixin.java index 544d2258..70ea2a6e 100644 --- a/src/main/java/com/alrex/parcool/mixin/client/ClientPlayerEntityMixin.java +++ b/src/main/java/com/alrex/parcool/mixin/client/ClientPlayerEntityMixin.java @@ -1,8 +1,8 @@ package com.alrex.parcool.mixin.client; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; import com.mojang.authlib.GameProfile; import net.minecraft.client.entity.player.AbstractClientPlayerEntity; import net.minecraft.client.entity.player.ClientPlayerEntity; diff --git a/src/main/java/com/alrex/parcool/mixin/client/ClientWorldMixin.java b/src/main/java/com/alrex/parcool/mixin/client/ClientWorldMixin.java index 0058c01d..71ce3a0a 100644 --- a/src/main/java/com/alrex/parcool/mixin/client/ClientWorldMixin.java +++ b/src/main/java/com/alrex/parcool/mixin/client/ClientWorldMixin.java @@ -1,8 +1,9 @@ package com.alrex.parcool.mixin.client; -import com.alrex.parcool.api.compatibility.ClientPlayerWrapper; import com.alrex.parcool.common.action.impl.HideInBlock; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.ClientPlayerWrapper; + import net.minecraft.block.BlockState; import net.minecraft.client.world.ClientWorld; import net.minecraft.profiler.IProfiler; diff --git a/src/main/java/com/alrex/parcool/mixin/client/PlayerModelMixin.java b/src/main/java/com/alrex/parcool/mixin/client/PlayerModelMixin.java index 6cff2bad..c7d2530f 100644 --- a/src/main/java/com/alrex/parcool/mixin/client/PlayerModelMixin.java +++ b/src/main/java/com/alrex/parcool/mixin/client/PlayerModelMixin.java @@ -1,8 +1,8 @@ package com.alrex.parcool.mixin.client; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.client.animation.PlayerModelTransformer; import com.alrex.parcool.common.capability.Animation; +import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.entity.model.BipedModel; diff --git a/src/main/java/com/alrex/parcool/mixin/client/PlayerRendererMixin.java b/src/main/java/com/alrex/parcool/mixin/client/PlayerRendererMixin.java index 41695408..39235ed0 100644 --- a/src/main/java/com/alrex/parcool/mixin/client/PlayerRendererMixin.java +++ b/src/main/java/com/alrex/parcool/mixin/client/PlayerRendererMixin.java @@ -1,8 +1,8 @@ package com.alrex.parcool.mixin.client; -import com.alrex.parcool.api.compatibility.AbstractClientPlayerWrapper; import com.alrex.parcool.client.animation.PlayerModelRotator; import com.alrex.parcool.common.capability.Animation; +import com.alrex.parcool.compatibility.AbstractClientPlayerWrapper; import com.mojang.blaze3d.matrix.MatrixStack; import net.minecraft.client.Minecraft; import net.minecraft.client.entity.player.AbstractClientPlayerEntity; diff --git a/src/main/java/com/alrex/parcool/mixin/common/EntityMixin.java b/src/main/java/com/alrex/parcool/mixin/common/EntityMixin.java index e221cdb9..b2ed9c44 100644 --- a/src/main/java/com/alrex/parcool/mixin/common/EntityMixin.java +++ b/src/main/java/com/alrex/parcool/mixin/common/EntityMixin.java @@ -1,8 +1,9 @@ package com.alrex.parcool.mixin.common; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.impl.HideInBlock; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; + import net.minecraft.entity.Entity; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.Tuple; diff --git a/src/main/java/com/alrex/parcool/mixin/common/LivingEntityMixin.java b/src/main/java/com/alrex/parcool/mixin/common/LivingEntityMixin.java index 23330b3c..47b1cead 100644 --- a/src/main/java/com/alrex/parcool/mixin/common/LivingEntityMixin.java +++ b/src/main/java/com/alrex/parcool/mixin/common/LivingEntityMixin.java @@ -1,13 +1,14 @@ package com.alrex.parcool.mixin.common; -import com.alrex.parcool.api.compatibility.EventBusWrapper; -import com.alrex.parcool.api.compatibility.LevelWrapper; -import com.alrex.parcool.api.compatibility.LivingEntityWrapper; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.action.impl.ChargeJump; import com.alrex.parcool.common.action.impl.ClimbPoles; import com.alrex.parcool.common.action.impl.ClimbUp; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.EventBusWrapper; +import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.LivingEntityWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; + import net.minecraft.block.*; import net.minecraft.entity.Entity; import net.minecraft.entity.EntityType; diff --git a/src/main/java/com/alrex/parcool/mixin/common/PlayerEntityMixin.java b/src/main/java/com/alrex/parcool/mixin/common/PlayerEntityMixin.java index c471d827..41578073 100644 --- a/src/main/java/com/alrex/parcool/mixin/common/PlayerEntityMixin.java +++ b/src/main/java/com/alrex/parcool/mixin/common/PlayerEntityMixin.java @@ -1,7 +1,8 @@ package com.alrex.parcool.mixin.common; -import com.alrex.parcool.api.compatibility.PlayerWrapper; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.PlayerWrapper; + import net.minecraft.entity.EntityType; import net.minecraft.entity.LivingEntity; import net.minecraft.entity.player.PlayerEntity; diff --git a/src/main/java/com/alrex/parcool/server/command/impl/ControlLimitationCommand.java b/src/main/java/com/alrex/parcool/server/command/impl/ControlLimitationCommand.java index 41e8c4bc..60dc8557 100644 --- a/src/main/java/com/alrex/parcool/server/command/impl/ControlLimitationCommand.java +++ b/src/main/java/com/alrex/parcool/server/command/impl/ControlLimitationCommand.java @@ -1,10 +1,10 @@ package com.alrex.parcool.server.command.impl; -import com.alrex.parcool.api.compatibility.MinecraftServerWrapper; -import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.api.unstable.Limitation; import com.alrex.parcool.common.action.Action; import com.alrex.parcool.common.action.ActionList; +import com.alrex.parcool.compatibility.MinecraftServerWrapper; +import com.alrex.parcool.compatibility.ServerPlayerWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.server.command.args.ActionArgumentType; import com.alrex.parcool.server.command.args.LimitationIDArgumentType; diff --git a/src/main/java/com/alrex/parcool/server/limitation/Limitations.java b/src/main/java/com/alrex/parcool/server/limitation/Limitations.java index aa449aa7..86c28ab0 100644 --- a/src/main/java/com/alrex/parcool/server/limitation/Limitations.java +++ b/src/main/java/com/alrex/parcool/server/limitation/Limitations.java @@ -1,11 +1,11 @@ package com.alrex.parcool.server.limitation; import com.alrex.parcool.ParCool; -import com.alrex.parcool.api.compatibility.ServerPlayerWrapper; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ServerLimitation; import com.alrex.parcool.common.network.SyncServerInfoMessage; +import com.alrex.parcool.compatibility.ServerPlayerWrapper; import com.alrex.parcool.utilities.JsonWriterUtil; import com.alrex.parcool.utilities.ServerUtil; import com.google.gson.stream.JsonReader; diff --git a/src/main/java/com/alrex/parcool/utilities/BipedModelUtil.java b/src/main/java/com/alrex/parcool/utilities/BipedModelUtil.java index f23ee6de..2012bca8 100644 --- a/src/main/java/com/alrex/parcool/utilities/BipedModelUtil.java +++ b/src/main/java/com/alrex/parcool/utilities/BipedModelUtil.java @@ -1,6 +1,7 @@ package com.alrex.parcool.utilities; -import com.alrex.parcool.api.compatibility.PlayerWrapper; +import com.alrex.parcool.compatibility.PlayerWrapper; + import net.minecraft.util.HandSide; public class BipedModelUtil { diff --git a/src/main/java/com/alrex/parcool/utilities/BufferUtil.java b/src/main/java/com/alrex/parcool/utilities/BufferUtil.java index b8b47a3d..6a5020d0 100644 --- a/src/main/java/com/alrex/parcool/utilities/BufferUtil.java +++ b/src/main/java/com/alrex/parcool/utilities/BufferUtil.java @@ -5,7 +5,7 @@ import java.nio.ByteBuffer; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; public class BufferUtil { ByteBuffer buffer; diff --git a/src/main/java/com/alrex/parcool/utilities/EntityUtil.java b/src/main/java/com/alrex/parcool/utilities/EntityUtil.java index 42c89ef3..ec927d02 100644 --- a/src/main/java/com/alrex/parcool/utilities/EntityUtil.java +++ b/src/main/java/com/alrex/parcool/utilities/EntityUtil.java @@ -1,7 +1,7 @@ package com.alrex.parcool.utilities; -import com.alrex.parcool.api.compatibility.EntityWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; +import com.alrex.parcool.compatibility.EntityWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; public class EntityUtil { public static void addVelocity(EntityWrapper entity, Vec3Wrapper vec) { diff --git a/src/main/java/com/alrex/parcool/utilities/VectorUtil.java b/src/main/java/com/alrex/parcool/utilities/VectorUtil.java index 2e5de1e0..8e2da538 100644 --- a/src/main/java/com/alrex/parcool/utilities/VectorUtil.java +++ b/src/main/java/com/alrex/parcool/utilities/VectorUtil.java @@ -1,6 +1,6 @@ package com.alrex.parcool.utilities; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; public class VectorUtil { public static double toYawDegree(Vec3Wrapper vec) { diff --git a/src/main/java/com/alrex/parcool/utilities/WorldUtil.java b/src/main/java/com/alrex/parcool/utilities/WorldUtil.java index e4e61656..f755d1dd 100644 --- a/src/main/java/com/alrex/parcool/utilities/WorldUtil.java +++ b/src/main/java/com/alrex/parcool/utilities/WorldUtil.java @@ -1,11 +1,12 @@ package com.alrex.parcool.utilities; -import com.alrex.parcool.api.compatibility.EntityWrapper; -import com.alrex.parcool.api.compatibility.LevelWrapper; -import com.alrex.parcool.api.compatibility.LivingEntityWrapper; -import com.alrex.parcool.api.compatibility.Vec3Wrapper; import com.alrex.parcool.common.action.impl.HangDown; import com.alrex.parcool.common.tags.BlockTags; +import com.alrex.parcool.compatibility.EntityWrapper; +import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.LivingEntityWrapper; +import com.alrex.parcool.compatibility.Vec3Wrapper; + import net.minecraft.block.*; import net.minecraft.state.properties.Half; import net.minecraft.util.Direction; From c36736dcff8420edf0cc564ddd052372d3af7dfa Mon Sep 17 00:00:00 2001 From: Thiago Santos Date: Sat, 3 May 2025 13:25:09 -0300 Subject: [PATCH 8/8] refactor: adding more compatibilty leayer elements --- src/main/java/com/alrex/parcool/ParCool.java | 5 +- .../parcool/common/action/impl/CatLeap.java | 9 +- .../common/action/impl/HideInBlock.java | 2 +- .../common/action/impl/HorizontalWallRun.java | 7 +- .../parcool/common/action/impl/Slide.java | 7 +- .../common/action/impl/VerticalWallRun.java | 7 +- .../parcool/common/action/impl/WallJump.java | 7 +- .../parcool/common/action/impl/WallSlide.java | 7 +- .../block/zipline/IronZiplineHookBlock.java | 3 +- .../block/zipline/ZiplineHookBlock.java | 3 +- .../block/zipline/ZiplineHookTileEntity.java | 63 +++++++------ .../common/entity/ParcoolEntityType.java | 4 +- .../entity/zipline/ZiplineRopeEntity.java | 30 ++++++- .../common/network/StartBreakfallMessage.java | 8 +- .../network/SyncActionStateMessage.java | 17 ++-- .../network/SyncClientInformationMessage.java | 17 ++-- .../common/network/SyncServerInfoMessage.java | 6 +- .../common/network/SyncStaminaMessage.java | 17 ++-- .../alrex/parcool/common/zipline/Zipline.java | 5 +- .../parcool/compatibility/AABBWrapper.java | 44 +++++++++ .../parcool/compatibility/AxisWrapper.java | 2 +- .../compatibility/BlockEntityWrapper.java | 10 +++ .../compatibility/BlockStateWrapper.java | 90 +++++++++++++++++++ .../parcool/compatibility/EntityWrapper.java | 17 ++-- .../parcool/compatibility/LevelWrapper.java | 50 +++++++---- .../compatibility/LivingEntityWrapper.java | 4 +- .../compatibility/MinecraftServerWrapper.java | 4 +- .../compatibility/NetworkContextWrapper.java | 40 +++++++++ .../parcool/compatibility/PlayerWrapper.java | 10 +-- .../compatibility/ServerEventWrapper.java | 17 ++++ .../compatibility/ServerPlayerWrapper.java | 2 +- .../parcool/compatibility/Vec3Wrapper.java | 13 ++- .../parcool/compatibility/WeakCache.java | 3 +- .../mixin/common/LivingEntityMixin.java | 6 +- .../server/limitation/Limitations.java | 7 +- .../alrex/parcool/utilities/WorldUtil.java | 50 +++++------ 36 files changed, 433 insertions(+), 160 deletions(-) create mode 100644 src/main/java/com/alrex/parcool/compatibility/AABBWrapper.java create mode 100644 src/main/java/com/alrex/parcool/compatibility/BlockStateWrapper.java create mode 100644 src/main/java/com/alrex/parcool/compatibility/NetworkContextWrapper.java create mode 100644 src/main/java/com/alrex/parcool/compatibility/ServerEventWrapper.java diff --git a/src/main/java/com/alrex/parcool/ParCool.java b/src/main/java/com/alrex/parcool/ParCool.java index b923d6a9..424f5c46 100644 --- a/src/main/java/com/alrex/parcool/ParCool.java +++ b/src/main/java/com/alrex/parcool/ParCool.java @@ -15,6 +15,7 @@ import com.alrex.parcool.common.potion.PotionRecipeRegistry; import com.alrex.parcool.common.potion.Potions; import com.alrex.parcool.common.registries.EventBusForgeRegistry; +import com.alrex.parcool.compatibility.ServerEventWrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.extern.AdditionalMods; import com.alrex.parcool.proxy.ClientProxy; @@ -77,8 +78,8 @@ public ParCool() { MinecraftForge.EVENT_BUS.addListener(this::registerCommand); MinecraftForge.EVENT_BUS.register(this); - MinecraftForge.EVENT_BUS.addListener(Limitations::init); - MinecraftForge.EVENT_BUS.addListener(Limitations::save); + MinecraftForge.EVENT_BUS.addListener((event) -> Limitations.init(new ServerEventWrapper(event))); + MinecraftForge.EVENT_BUS.addListener((event) -> Limitations.save(new ServerEventWrapper(event))); Blocks.register(FMLJavaModLoadingContext.get().getModEventBus()); Items.register(FMLJavaModLoadingContext.get().getModEventBus()); diff --git a/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java b/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java index 96b982bc..7c8466a0 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/CatLeap.java @@ -8,14 +8,13 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.BlockStateWrapper; import com.alrex.parcool.compatibility.ClientPlayerWrapper; import com.alrex.parcool.compatibility.LevelWrapper; import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.block.BlockRenderType; -import net.minecraft.block.BlockState; -import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; import net.minecraftforge.api.distmarker.Dist; @@ -128,8 +127,8 @@ private void spawnJumpEffect(PlayerWrapper player, Vec3Wrapper jumpDirection) { BlockPos blockpos = new BlockPos(pos.add(0, -0.2, 0)); if (!level.isLoaded(blockpos)) return; float width = player.getBbWidth(); - BlockState blockstate = level.getBlockState(blockpos); - if (blockstate.getRenderShape() != BlockRenderType.INVISIBLE) { + BlockStateWrapper blockState = level.getBlockState(blockpos); + if (blockState.getRenderShape() != BlockRenderType.INVISIBLE) { for (int i = 0; i < 20; i++) { Vec3Wrapper particlePos = new Vec3Wrapper( pos.x() + (jumpDirection.x() * -0.5 + player.getRandom().nextDouble() - 0.5D) * width, @@ -138,7 +137,7 @@ private void spawnJumpEffect(PlayerWrapper player, Vec3Wrapper jumpDirection) { ); Vec3Wrapper particleSpeed = particlePos.subtract(pos).normalize().scale(2.5 + 8 * player.getRandom().nextDouble()).add(0, 1.5, 0); level.addParticle( - new BlockParticleData(ParticleTypes.BLOCK, blockstate).setPos(blockpos), + blockState.getBlockParticleData(ParticleTypes.BLOCK, blockpos), particlePos.x(), particlePos.y(), particlePos.z(), diff --git a/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java b/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java index 6eacccf6..eeb17db1 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/HideInBlock.java @@ -228,7 +228,7 @@ private void spawnOnHideParticles(PlayerWrapper player) { for (int x = minX; x <= maxX; x++) { BlockPos pos = new BlockPos(x, y, z); if (!world.isLoaded(pos)) break; - Minecraft.getInstance().particleEngine.destroy(pos, world.getBlockState(pos)); + world.getBlockState(pos).destroyParticle(pos); } } } diff --git a/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java b/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java index 29ebfb5d..602d11b0 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/HorizontalWallRun.java @@ -9,6 +9,7 @@ import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ActionInfo; +import com.alrex.parcool.compatibility.BlockStateWrapper; import com.alrex.parcool.compatibility.LevelWrapper; import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.compatibility.Vec3Wrapper; @@ -17,10 +18,8 @@ import com.alrex.parcool.utilities.VectorUtil; import com.alrex.parcool.utilities.WorldUtil; import net.minecraft.block.BlockRenderType; -import net.minecraft.block.BlockState; import net.minecraft.entity.ai.attributes.Attributes; import net.minecraft.entity.ai.attributes.ModifiableAttributeInstance; -import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; import net.minecraftforge.api.distmarker.Dist; @@ -239,7 +238,7 @@ public void spawnRunningParticle(PlayerWrapper player) { ); if (!level.isLoaded(leanedBlock)) return; float width = player.getBbWidth(); - BlockState blockstate = level.getBlockState(leanedBlock); + BlockStateWrapper blockstate = level.getBlockState(leanedBlock); Vec3Wrapper wallDirection = runningWallDirection.normalize(); Vec3Wrapper orthogonalToWallVec = wallDirection.yRot((float) (Math.PI / 2)); @@ -255,7 +254,7 @@ public void spawnRunningParticle(PlayerWrapper player) { .scale(3 + 6 * player.getRandom().nextDouble()) .add(0, 1.5, 0); level.addParticle( - new BlockParticleData(ParticleTypes.BLOCK, blockstate).setPos(leanedBlock), + blockstate.getBlockParticleData(ParticleTypes.BLOCK, leanedBlock), particlePos.x(), particlePos.y(), particlePos.z(), diff --git a/src/main/java/com/alrex/parcool/common/action/impl/Slide.java b/src/main/java/com/alrex/parcool/common/action/impl/Slide.java index aa3c872a..ba7b0a08 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/Slide.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/Slide.java @@ -10,15 +10,14 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.BlockStateWrapper; import com.alrex.parcool.compatibility.LevelWrapper; import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import net.minecraft.block.BlockRenderType; -import net.minecraft.block.BlockState; import net.minecraft.entity.ai.attributes.Attributes; import net.minecraft.entity.ai.attributes.ModifiableAttributeInstance; -import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; import net.minecraftforge.api.distmarker.Dist; @@ -128,7 +127,7 @@ private void spawnSlidingParticle(PlayerWrapper player) { if (!ParCoolConfig.Client.Booleans.EnableActionParticles.get()) return; LevelWrapper level = player.getLevel(); Vec3Wrapper pos = player.position(); - BlockState feetBlock = player.getBelowBlockState(); + BlockStateWrapper feetBlock = player.getBelowBlockState(); float width = player.getBbWidth(); Vec3Wrapper direction = getSlidingVector(); if (direction == null) return; @@ -144,7 +143,7 @@ private void spawnSlidingParticle(PlayerWrapper player) { .scale(2.5 + 5 * player.getRandom().nextDouble()) .add(0, 1.5, 0); level.addParticle( - new BlockParticleData(ParticleTypes.BLOCK, feetBlock).setPos(new BlockPos(player.position().add(0, -0.5, 0))), + feetBlock.getBlockParticleData(ParticleTypes.BLOCK, new BlockPos(player.position().add(0, -0.5, 0))), particlePos.x(), particlePos.y(), particlePos.z(), diff --git a/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java b/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java index ec0c131d..c7080842 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/VerticalWallRun.java @@ -8,6 +8,7 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.BlockStateWrapper; import com.alrex.parcool.compatibility.LevelWrapper; import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.compatibility.Vec3Wrapper; @@ -15,8 +16,6 @@ import com.alrex.parcool.utilities.VectorUtil; import com.alrex.parcool.utilities.WorldUtil; import net.minecraft.block.BlockRenderType; -import net.minecraft.block.BlockState; -import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; import net.minecraftforge.api.distmarker.Dist; @@ -145,7 +144,7 @@ public void spawnRunningParticle(PlayerWrapper player) { ); if (!level.isLoaded(leanedBlock)) return; float width = player.getBbWidth(); - BlockState blockstate = level.getBlockState(leanedBlock); + BlockStateWrapper blockstate = level.getBlockState(leanedBlock); Vec3Wrapper normalizedWallVec = wallDirection.normalize(); Vec3Wrapper orthogonalToWallVec = normalizedWallVec.yRot((float) (Math.PI / 2)); @@ -161,7 +160,7 @@ public void spawnRunningParticle(PlayerWrapper player) { .scale(2 + 4 * player.getRandom().nextDouble()) .add(0, 0.5, 0); level.addParticle( - new BlockParticleData(ParticleTypes.BLOCK, blockstate).setPos(leanedBlock), + blockstate.getBlockParticleData(ParticleTypes.BLOCK, leanedBlock), particlePos.x(), particlePos.y(), particlePos.z(), diff --git a/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java b/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java index a39dd74b..77d4c21f 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/WallJump.java @@ -9,14 +9,13 @@ import com.alrex.parcool.common.capability.Animation; import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.BlockStateWrapper; import com.alrex.parcool.compatibility.LevelWrapper; import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.WorldUtil; import net.minecraft.block.BlockRenderType; -import net.minecraft.block.BlockState; -import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; import net.minecraftforge.api.distmarker.Dist; @@ -246,7 +245,7 @@ private void spawnJumpParticles(PlayerWrapper player, Vec3Wrapper wallDirection, ); if (!level.isLoaded(leanedBlock)) return; float width = player.getBbWidth(); - BlockState blockstate = level.getBlockState(leanedBlock); + BlockStateWrapper blockstate = level.getBlockState(leanedBlock); Vec3Wrapper horizontalJumpDirection = jumpDirection.multiply(1, 0, 1).normalize(); @@ -276,7 +275,7 @@ private void spawnJumpParticles(PlayerWrapper player, Vec3Wrapper wallDirection, .scale(3 + 9 * player.getRandom().nextDouble()) .add(0, -jumpDirection.y() * 3 * player.getRandom().nextDouble(), 0); level.addParticle( - new BlockParticleData(ParticleTypes.BLOCK, blockstate).setPos(leanedBlock), + blockstate.getBlockParticleData(ParticleTypes.BLOCK, leanedBlock), particlePos.x(), particlePos.y(), particlePos.z(), diff --git a/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java b/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java index e0bbdb6f..735e6e42 100644 --- a/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java +++ b/src/main/java/com/alrex/parcool/common/action/impl/WallSlide.java @@ -8,14 +8,13 @@ import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.damage.DamageSources; +import com.alrex.parcool.compatibility.BlockStateWrapper; import com.alrex.parcool.compatibility.LevelWrapper; import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.compatibility.Vec3Wrapper; import com.alrex.parcool.config.ParCoolConfig; import com.alrex.parcool.utilities.WorldUtil; import net.minecraft.block.BlockRenderType; -import net.minecraft.block.BlockState; -import net.minecraft.particles.BlockParticleData; import net.minecraft.particles.ParticleTypes; import net.minecraft.util.math.BlockPos; import net.minecraftforge.api.distmarker.Dist; @@ -131,7 +130,7 @@ private void spawnSlideParticle(PlayerWrapper player) { ); if (!level.isLoaded(leanedBlock)) return; float width = player.getBbWidth(); - BlockState blockstate = level.getBlockState(leanedBlock); + BlockStateWrapper blockstate = level.getBlockState(leanedBlock); Vec3Wrapper normalizedWallVec = leanedWallDirection.normalize(); Vec3Wrapper orthogonalToWallVec = normalizedWallVec.yRot((float) (Math.PI / 2)); @@ -147,7 +146,7 @@ private void spawnSlideParticle(PlayerWrapper player) { .scale(0.05) .add(0, -0.5 - player.getRandom().nextDouble(), 0); level.addParticle( - new BlockParticleData(ParticleTypes.BLOCK, blockstate).setPos(leanedBlock), + blockstate.getBlockParticleData(ParticleTypes.BLOCK, leanedBlock), particlePos.x(), particlePos.y(), particlePos.z(), diff --git a/src/main/java/com/alrex/parcool/common/block/zipline/IronZiplineHookBlock.java b/src/main/java/com/alrex/parcool/common/block/zipline/IronZiplineHookBlock.java index 6e875238..f6b8296e 100644 --- a/src/main/java/com/alrex/parcool/common/block/zipline/IronZiplineHookBlock.java +++ b/src/main/java/com/alrex/parcool/common/block/zipline/IronZiplineHookBlock.java @@ -1,6 +1,7 @@ package com.alrex.parcool.common.block.zipline; import com.alrex.parcool.common.block.BlockStateProperties; +import com.alrex.parcool.compatibility.BlockStateWrapper; import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.compatibility.Vec3Wrapper; @@ -51,7 +52,7 @@ public IronZiplineHookBlock(Properties p_i48440_1_) { } @Override - public Vec3Wrapper getActualZiplinePoint(BlockPos pos, BlockState state) { + public Vec3Wrapper getActualZiplinePoint(BlockPos pos, BlockStateWrapper state) { Direction direction = state.getValue(FACING); return new Vec3Wrapper( pos.getX() + 0.5 - direction.getStepX() * 0.2, diff --git a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java index 2152a881..253af62c 100644 --- a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java +++ b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookBlock.java @@ -3,6 +3,7 @@ import com.alrex.parcool.api.SoundEvents; import com.alrex.parcool.common.block.TileEntities; import com.alrex.parcool.compatibility.BlockEntityWrapper; +import com.alrex.parcool.compatibility.BlockStateWrapper; import com.alrex.parcool.compatibility.ContainersWrapper; import com.alrex.parcool.compatibility.InteractionResultWrapper; import com.alrex.parcool.compatibility.LevelWrapper; @@ -41,7 +42,7 @@ public ZiplineHookBlock(Properties p_i48440_1_) { registerDefaultState(defaultBlockState().setValue(FACING, Direction.UP)); } - public Vec3Wrapper getActualZiplinePoint(BlockPos pos, BlockState state) { + public Vec3Wrapper getActualZiplinePoint(BlockPos pos, BlockStateWrapper state) { return new Vec3Wrapper(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5); } diff --git a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookTileEntity.java b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookTileEntity.java index 8e8f29a7..79694932 100644 --- a/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookTileEntity.java +++ b/src/main/java/com/alrex/parcool/common/block/zipline/ZiplineHookTileEntity.java @@ -3,6 +3,7 @@ import com.alrex.parcool.common.entity.zipline.ZiplineRopeEntity; import com.alrex.parcool.common.item.Items; import com.alrex.parcool.common.item.zipline.ZiplineRopeItem; +import com.alrex.parcool.compatibility.BlockStateWrapper; import com.alrex.parcool.compatibility.LevelWrapper; import com.alrex.parcool.compatibility.Vec3Wrapper; @@ -24,8 +25,21 @@ import java.util.stream.Collectors; public class ZiplineHookTileEntity extends TileEntity implements ITickableTileEntity { - public ZiplineHookTileEntity(TileEntityType p_i48289_1_) { - super(p_i48289_1_); + private LevelWrapper levelWrapper; + + public ZiplineHookTileEntity(TileEntityType entityType) { + super(entityType); + setLevelWrapper(); + } + + private void setLevelWrapper() { + levelWrapper = level == null ? null : LevelWrapper.get(level); + } + + @Override + public void setLevelAndPosition(World level, BlockPos position) { + super.setLevelAndPosition(level, position); + setLevelWrapper(); } private final TreeMap connections = new TreeMap<>(); @@ -42,15 +56,15 @@ private TreeMap getConnectionInfo() { } public List removeAllConnection() { - if (level == null) return Collections.EMPTY_LIST; + if (levelWrapper == null) return Collections.EMPTY_LIST; getConnectionPoints().stream() - .filter(level::isLoaded) - .map(level::getBlockEntity) - .map(it -> it instanceof ZiplineHookTileEntity ? (ZiplineHookTileEntity) it : null) + .filter(levelWrapper::isLoaded) + .map(levelWrapper::getBlockEntity) + .map(it -> it.is(ZiplineHookTileEntity.class) ? (ZiplineHookTileEntity) it.getInstance() : null) .filter(Objects::nonNull) .forEach(it -> it.onPairHookRegistrationRemoved(this)); List itemStacks = Collections.EMPTY_LIST; - if (!level.isClientSide()) { + if (!levelWrapper.isClientSide()) { connectionEntities.values().forEach(ZiplineRopeEntity::remove); itemStacks = connections.values().stream().map(it -> { ItemStack stack = new ItemStack(Items.ZIPLINE_ROPE::get); @@ -74,14 +88,14 @@ private void onPairHookUnloaded(ZiplineHookTileEntity removedPair) { @Override public void onChunkUnloaded() { super.onChunkUnloaded(); - if (level != null) { + if (levelWrapper != null) { getConnectionPoints().stream() - .filter(level::isLoaded) - .map(level::getBlockEntity) - .map(it -> it instanceof ZiplineHookTileEntity ? (ZiplineHookTileEntity) it : null) + .filter(levelWrapper::isLoaded) + .map(levelWrapper::getBlockEntity) + .map(it -> it.is(ZiplineHookTileEntity.class) ? (ZiplineHookTileEntity) it.getInstance() : null) .filter(Objects::nonNull) .forEach(it -> it.onPairHookUnloaded(this)); - if (!level.isClientSide()) { + if (!levelWrapper.isClientSide()) { connectionEntities.values().forEach(ZiplineRopeEntity::remove); } connectionEntities.clear(); @@ -89,9 +103,9 @@ public void onChunkUnloaded() { } public Vec3Wrapper getActualZiplinePoint(@Nullable BlockPos connected) { - if (level == null) + if (levelWrapper == null) new Vec3Wrapper(getBlockPos().getX() + 0.5, getBlockPos().getY() + 0.5, getBlockPos().getZ() + 0.5); - BlockState state = level.getBlockState(this.getBlockPos()); + BlockStateWrapper state = levelWrapper.getBlockState(this.getBlockPos()); Block block = state.getBlock(); if (block instanceof ZiplineHookBlock) { return ((ZiplineHookBlock) block).getActualZiplinePoint(this.getBlockPos(), state); @@ -102,11 +116,11 @@ public Vec3Wrapper getActualZiplinePoint(@Nullable BlockPos connected) { public boolean connectTo(ZiplineHookTileEntity target, ZiplineInfo info) { if (this == target) return false; - if (level != null && !level.isClientSide()) { + if (levelWrapper != null && !levelWrapper.isClientSide()) { if (this.getConnectionPoints().stream().anyMatch(target.getBlockPos()::equals)) { return false; } - ZiplineRopeEntity ropeEntity = spawnRope(level, target, info); + ZiplineRopeEntity ropeEntity = spawnRope(levelWrapper, target, info); if (ropeEntity != null) { this.getConnectionInfo().put(target.getBlockPos(), info); target.getConnectionInfo().put(this.getBlockPos(), info); @@ -117,13 +131,12 @@ public boolean connectTo(ZiplineHookTileEntity target, ZiplineInfo info) { } @Nullable - private ZiplineRopeEntity spawnRope(World level, ZiplineHookTileEntity target, ZiplineInfo info) { - LevelWrapper levelWrapper = LevelWrapper.get(level); + private ZiplineRopeEntity spawnRope(LevelWrapper levelWrapper, ZiplineHookTileEntity target, ZiplineInfo info) { if (levelWrapper.isClientSide()) return null; if (target.connectionEntities.containsKey(this.getBlockPos())) return null; - ZiplineRopeEntity entity = new ZiplineRopeEntity(level, getBlockPos(), target.getBlockPos(), info); - boolean result = level.addFreshEntity(entity); + ZiplineRopeEntity entity = new ZiplineRopeEntity(levelWrapper, getBlockPos(), target.getBlockPos(), info); + boolean result = levelWrapper.addFreshEntity(entity); if (result) { this.connectionEntities.put(target.getBlockPos(), entity); target.connectionEntities.put(this.getBlockPos(), entity); @@ -196,18 +209,18 @@ public void handleUpdateTag(BlockState state, CompoundNBT tag) { @Override public void tick() { - if (level != null && !level.isClientSide() && connectionEntities.size() < getConnectionPoints().size()) { + if (levelWrapper != null && !levelWrapper.isClientSide() && connectionEntities.size() < getConnectionPoints().size()) { List tileEntities = getConnectionPoints() .stream() .filter(it -> !connectionEntities.containsKey(it)) - .filter(level::isLoaded) - .map(level::getBlockEntity) - .map(it -> it instanceof ZiplineHookTileEntity ? (ZiplineHookTileEntity) it : null) + .filter(levelWrapper::isLoaded) + .map(levelWrapper::getBlockEntity) + .map(it -> it.is(ZiplineHookTileEntity.class) ? (ZiplineHookTileEntity) it.getInstance() : null) .filter(Objects::nonNull) .collect(Collectors.toList()); tileEntities.forEach(it -> { if (it.getConnectionPoints().contains(this.getBlockPos())) { - this.spawnRope(level, it, getConnectionInfo().get(it.getBlockPos())); + this.spawnRope(levelWrapper, it, getConnectionInfo().get(it.getBlockPos())); } else { this.getConnectionPoints().remove(it.getBlockPos()); } diff --git a/src/main/java/com/alrex/parcool/common/entity/ParcoolEntityType.java b/src/main/java/com/alrex/parcool/common/entity/ParcoolEntityType.java index 5acb82bc..2ba26209 100644 --- a/src/main/java/com/alrex/parcool/common/entity/ParcoolEntityType.java +++ b/src/main/java/com/alrex/parcool/common/entity/ParcoolEntityType.java @@ -12,8 +12,8 @@ public class ParcoolEntityType { private static final DeferredRegister> REGISTER = DeferredRegister.create(ForgeRegistries.ENTITIES, ParCool.MOD_ID); public static final RegistryObject> ZIPLINE_ROPE - = REGISTER.register("zipline_rope", () -> net.minecraft.entity.EntityType.Builder - .of((net.minecraft.entity.EntityType.IFactory) ZiplineRopeEntity::new, EntityClassification.MISC) + = REGISTER.register("zipline_rope", () -> EntityType.Builder + .of((EntityType.IFactory) ZiplineRopeEntity::new, EntityClassification.MISC) .noSave() .clientTrackingRange(32) .updateInterval(Integer.MAX_VALUE) diff --git a/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java b/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java index ae67fba8..d92d35ab 100644 --- a/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java +++ b/src/main/java/com/alrex/parcool/common/entity/zipline/ZiplineRopeEntity.java @@ -2,9 +2,11 @@ import com.alrex.parcool.common.block.zipline.ZiplineHookTileEntity; import com.alrex.parcool.common.block.zipline.ZiplineInfo; +import com.alrex.parcool.common.entity.ParcoolEntityType; import com.alrex.parcool.common.item.zipline.ZiplineRopeItem; import com.alrex.parcool.common.zipline.Zipline; import com.alrex.parcool.common.zipline.ZiplineType; +import com.alrex.parcool.compatibility.LevelWrapper; import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.compatibility.Vec3Wrapper; @@ -32,6 +34,7 @@ public class ZiplineRopeEntity extends Entity { private static final DataParameter DATA_END_POS; private static final DataParameter DATA_COLOR; private static final DataParameter DATA_ZIP_TYPE; + private Object levelWrapper; static { DATA_START_POS = EntityDataManager.defineId(ZiplineRopeEntity.class, DataSerializers.BLOCK_POS); @@ -42,12 +45,28 @@ public class ZiplineRopeEntity extends Entity { private EntitySize size; - public ZiplineRopeEntity(EntityType p_i48580_1_, World p_i48580_2_) { - super(p_i48580_1_, p_i48580_2_); + public ZiplineRopeEntity(EntityType entityType, World level) { + super(entityType, level); + setLevelWrapper(); + } + + public ZiplineRopeEntity(EntityType entityType, LevelWrapper level) { + super(entityType, level.getInstance()); + levelWrapper = level; + } + + private void setLevelWrapper() { + levelWrapper = level == null ? null : LevelWrapper.get(level); + } + + @Override + public void setLevel(World level) { + super.setLevel(level); + setLevelWrapper(); } public ZiplineRopeEntity(World world, BlockPos start, BlockPos end, ZiplineInfo info) { - super(com.alrex.parcool.common.entity.ParcoolEntityType.ZIPLINE_ROPE.get(), world); + super(ParcoolEntityType.ZIPLINE_ROPE.get(), world); setStartPos(start); setEndPos(end); setColor(info.getColor()); @@ -56,6 +75,11 @@ public ZiplineRopeEntity(World world, BlockPos start, BlockPos end, ZiplineInfo noPhysics = true; forcedLoading = true; size = EntitySize.fixed(Math.max(Math.abs(end.getX() - start.getX()), Math.abs(end.getZ() - start.getZ())) + 0.3f, Math.abs(end.getY() - start.getY()) + 0.3f); + setLevelWrapper(); + } + + public ZiplineRopeEntity(LevelWrapper level, BlockPos start, BlockPos end, ZiplineInfo info) { + this(level.getInstance(), start, end, info); } private BlockPos zipline_start; diff --git a/src/main/java/com/alrex/parcool/common/network/StartBreakfallMessage.java b/src/main/java/com/alrex/parcool/common/network/StartBreakfallMessage.java index bfe0b8d4..c9d53cf5 100644 --- a/src/main/java/com/alrex/parcool/common/network/StartBreakfallMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/StartBreakfallMessage.java @@ -5,6 +5,7 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.compatibility.ChannelInstanceWrapper; import com.alrex.parcool.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.compatibility.NetworkContextWrapper; import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.compatibility.ServerPlayerWrapper; @@ -40,8 +41,9 @@ public static StartBreakfallMessage decode(PacketBuffer packet) { @OnlyIn(Dist.CLIENT) public void handleClient(Supplier contextSupplier) { - contextSupplier.get().enqueueWork(() -> { - if (contextSupplier.get().getNetworkManager().getDirection() == PacketDirection.CLIENTBOUND) { + Supplier supplier = NetworkContextWrapper.getSupplier(contextSupplier); + supplier.get().enqueueWork(() -> { + if (supplier.get().getDirection() == PacketDirection.CLIENTBOUND) { PlayerWrapper player = ClientPlayerWrapper.get(); if (player == null) return; if (!playerID.equals(player.getUUID())) return; @@ -54,7 +56,7 @@ public void handleClient(Supplier contextSupplier) { parkourability.get(BreakfallReady.class).startBreakfall(player, parkourability, stamina, justTimed); } }); - contextSupplier.get().setPacketHandled(true); + supplier.get().setPacketHandled(true); } @OnlyIn(Dist.DEDICATED_SERVER) diff --git a/src/main/java/com/alrex/parcool/common/network/SyncActionStateMessage.java b/src/main/java/com/alrex/parcool/common/network/SyncActionStateMessage.java index be427a0c..779f16f8 100644 --- a/src/main/java/com/alrex/parcool/common/network/SyncActionStateMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/SyncActionStateMessage.java @@ -5,6 +5,7 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.compatibility.EventBusWrapper; import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.NetworkContextWrapper; import com.alrex.parcool.compatibility.PlayerWrapper; import net.minecraft.network.PacketBuffer; @@ -44,8 +45,9 @@ public static SyncActionStateMessage decode(PacketBuffer packetBuffer) { @OnlyIn(Dist.DEDICATED_SERVER) public void handleServer(Supplier contextSupplier) { - contextSupplier.get().enqueueWork(() -> { - PlayerWrapper player = PlayerWrapper.get(contextSupplier); + Supplier supplier = NetworkContextWrapper.getSupplier(contextSupplier); + supplier.get().enqueueWork(() -> { + PlayerWrapper player = PlayerWrapper.get(supplier); ParCool.CHANNEL_INSTANCE.send(PacketDistributor.ALL.noArg(), this); if (player == null) return; @@ -78,22 +80,23 @@ public void handleServer(Supplier contextSupplier) { } } }); - contextSupplier.get().setPacketHandled(true); + supplier.get().setPacketHandled(true); } @OnlyIn(Dist.CLIENT) public void handleClient(Supplier contextSupplier) { - contextSupplier.get().enqueueWork(() -> { + Supplier supplier = NetworkContextWrapper.getSupplier(contextSupplier); + supplier.get().enqueueWork(() -> { PlayerWrapper player; boolean clientSide; - if (contextSupplier.get().getDirection().getReceptionSide() == LogicalSide.CLIENT) { + if (supplier.get().getReceptionSide() == LogicalSide.CLIENT) { LevelWrapper world = LevelWrapper.get(); if (world == null) return; player = PlayerWrapper.get(world, senderUUID); if (player == null || player.isLocalPlayer()) return; clientSide = true; } else { - player = PlayerWrapper.get(contextSupplier); + player = PlayerWrapper.get(supplier); ParCool.CHANNEL_INSTANCE.send(PacketDistributor.ALL.noArg(), this); if (player == null) return; clientSide = false; @@ -136,7 +139,7 @@ public void handleClient(Supplier contextSupplier) { } } }); - contextSupplier.get().setPacketHandled(true); + supplier.get().setPacketHandled(true); } @OnlyIn(Dist.CLIENT) diff --git a/src/main/java/com/alrex/parcool/common/network/SyncClientInformationMessage.java b/src/main/java/com/alrex/parcool/common/network/SyncClientInformationMessage.java index d00a103a..525cd3a4 100644 --- a/src/main/java/com/alrex/parcool/common/network/SyncClientInformationMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/SyncClientInformationMessage.java @@ -5,6 +5,7 @@ import com.alrex.parcool.common.info.ClientSetting; import com.alrex.parcool.compatibility.ClientPlayerWrapper; import com.alrex.parcool.compatibility.MinecraftServerWrapper; +import com.alrex.parcool.compatibility.NetworkContextWrapper; import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.compatibility.ServerPlayerWrapper; import com.alrex.parcool.server.limitation.Limitations; @@ -46,13 +47,14 @@ public static SyncClientInformationMessage decode(PacketBuffer packet) { @OnlyIn(Dist.CLIENT) public void handleClient(Supplier contextSupplier) { - contextSupplier.get().enqueueWork(() -> { + Supplier supplier = NetworkContextWrapper.getSupplier(contextSupplier); + supplier.get().enqueueWork(() -> { PlayerWrapper player; - if (contextSupplier.get().getDirection().getReceptionSide() == LogicalSide.CLIENT) { + if (supplier.get().getReceptionSide() == LogicalSide.CLIENT) { player = MinecraftServerWrapper.getPlayer(playerID); if (player == null) return; } else { - ServerPlayerWrapper serverPlayer = ServerPlayerWrapper.get(contextSupplier); + ServerPlayerWrapper serverPlayer = ServerPlayerWrapper.get(supplier); player = serverPlayer; if (player == null) return; ParCool.CHANNEL_INSTANCE.send(PacketDistributor.ALL.noArg(), this); @@ -68,12 +70,13 @@ public void handleClient(Supplier contextSupplier) { data.rewind(); } }); - contextSupplier.get().setPacketHandled(true); + supplier.get().setPacketHandled(true); } public void handleServer(Supplier contextSupplier) { - contextSupplier.get().enqueueWork(() -> { - ServerPlayerWrapper player = ServerPlayerWrapper.get(contextSupplier); + Supplier supplier = NetworkContextWrapper.getSupplier(contextSupplier); + supplier.get().enqueueWork(() -> { + ServerPlayerWrapper player = ServerPlayerWrapper.get(supplier); if (player == null) return; ParCool.CHANNEL_INSTANCE.send(PacketDistributor.ALL.noArg(), this); @@ -86,7 +89,7 @@ public void handleServer(Supplier contextSupplier) { parkourability.getActionInfo().setClientSetting(ClientSetting.readFrom(data)); data.rewind(); }); - contextSupplier.get().setPacketHandled(true); + supplier.get().setPacketHandled(true); } public void logReceived(PlayerWrapper player) { diff --git a/src/main/java/com/alrex/parcool/common/network/SyncServerInfoMessage.java b/src/main/java/com/alrex/parcool/common/network/SyncServerInfoMessage.java index 3cb6326f..741ec09b 100644 --- a/src/main/java/com/alrex/parcool/common/network/SyncServerInfoMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/SyncServerInfoMessage.java @@ -5,6 +5,7 @@ import com.alrex.parcool.common.capability.Parkourability; import com.alrex.parcool.common.info.ServerLimitation; import com.alrex.parcool.compatibility.ClientPlayerWrapper; +import com.alrex.parcool.compatibility.NetworkContextWrapper; import com.alrex.parcool.compatibility.PlayerPacketDistributor; import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.compatibility.ServerPlayerWrapper; @@ -46,7 +47,8 @@ public static SyncServerInfoMessage decode(PacketBuffer packet) { @OnlyIn(Dist.CLIENT) public void handle(Supplier contextSupplier) { - contextSupplier.get().enqueueWork(() -> { + Supplier supplier = NetworkContextWrapper.getSupplier(contextSupplier); + supplier.get().enqueueWork(() -> { ClientPlayerWrapper player = ClientPlayerWrapper.get(); if (player == null) return; Parkourability parkourability = Parkourability.get(player); @@ -60,7 +62,7 @@ public void handle(Supplier contextSupplier) { stamina.setExhaustion(staminaExhausted); } }); - contextSupplier.get().setPacketHandled(true); + supplier.get().setPacketHandled(true); } public void logReceived(PlayerWrapper player) { diff --git a/src/main/java/com/alrex/parcool/common/network/SyncStaminaMessage.java b/src/main/java/com/alrex/parcool/common/network/SyncStaminaMessage.java index 2a4e93cf..f28fba14 100644 --- a/src/main/java/com/alrex/parcool/common/network/SyncStaminaMessage.java +++ b/src/main/java/com/alrex/parcool/common/network/SyncStaminaMessage.java @@ -4,6 +4,7 @@ import com.alrex.parcool.common.capability.IStamina; import com.alrex.parcool.common.capability.stamina.OtherStamina; import com.alrex.parcool.compatibility.LevelWrapper; +import com.alrex.parcool.compatibility.NetworkContextWrapper; import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.compatibility.ServerPlayerWrapper; @@ -49,9 +50,10 @@ public static SyncStaminaMessage decode(PacketBuffer packet) { @OnlyIn(Dist.DEDICATED_SERVER) public void handleServer(Supplier contextSupplier) { - contextSupplier.get().enqueueWork(() -> { + Supplier supplier = NetworkContextWrapper.getSupplier(contextSupplier); + supplier.get().enqueueWork(() -> { ServerPlayerWrapper player; - player = ServerPlayerWrapper.get(contextSupplier); + player = ServerPlayerWrapper.get(supplier); ParCool.CHANNEL_INSTANCE.send(PacketDistributor.ALL.noArg(), this); if (player == null) return; IStamina stamina = IStamina.get(player); @@ -65,21 +67,22 @@ public void handleServer(Supplier contextSupplier) { stamina.set(this.stamina); stamina.setExhaustion(exhausted); }); - contextSupplier.get().setPacketHandled(true); + supplier.get().setPacketHandled(true); } @OnlyIn(Dist.CLIENT) public void handleClient(Supplier contextSupplier) { - contextSupplier.get().enqueueWork(() -> { + Supplier supplier = NetworkContextWrapper.getSupplier(contextSupplier); + supplier.get().enqueueWork(() -> { ServerPlayerWrapper serverPlayer = null; PlayerWrapper player; - if (contextSupplier.get().getDirection().getReceptionSide() == LogicalSide.CLIENT) { + if (supplier.get().getReceptionSide() == LogicalSide.CLIENT) { LevelWrapper world = LevelWrapper.get(); if (world == null) return; player = PlayerWrapper.get(world, playerID); if (player == null || player.isLocalPlayer()) return; } else { - player = serverPlayer = ServerPlayerWrapper.get(contextSupplier); + player = serverPlayer = ServerPlayerWrapper.get(supplier); ParCool.CHANNEL_INSTANCE.send(PacketDistributor.ALL.noArg(), this); if (player == null) return; } @@ -94,7 +97,7 @@ public void handleClient(Supplier contextSupplier) { stamina.set(this.stamina); stamina.setExhaustion(exhausted); }); - contextSupplier.get().setPacketHandled(true); + supplier.get().setPacketHandled(true); } @OnlyIn(Dist.CLIENT) diff --git a/src/main/java/com/alrex/parcool/common/zipline/Zipline.java b/src/main/java/com/alrex/parcool/common/zipline/Zipline.java index f336b08d..c1ae2c8d 100644 --- a/src/main/java/com/alrex/parcool/common/zipline/Zipline.java +++ b/src/main/java/com/alrex/parcool/common/zipline/Zipline.java @@ -1,11 +1,10 @@ package com.alrex.parcool.common.zipline; import com.alrex.parcool.common.entity.zipline.ZiplineRopeEntity; +import com.alrex.parcool.compatibility.AABBWrapper; import com.alrex.parcool.compatibility.LevelWrapper; import com.alrex.parcool.compatibility.PlayerWrapper; import com.alrex.parcool.compatibility.Vec3Wrapper; - -import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; @@ -82,7 +81,7 @@ public boolean conflictsWithSomething(World world) { for (int i = 1; i < count - 1; i++) { Vec3Wrapper midPoint = getMidPoint(((float) i / count)); final double d = 0.2; - if (!world.noCollision(new AxisAlignedBB( + if (!world.noCollision(new AABBWrapper( midPoint.subtract(d, d, d), midPoint.add(d, d, d) ))) { diff --git a/src/main/java/com/alrex/parcool/compatibility/AABBWrapper.java b/src/main/java/com/alrex/parcool/compatibility/AABBWrapper.java new file mode 100644 index 00000000..d1e611a5 --- /dev/null +++ b/src/main/java/com/alrex/parcool/compatibility/AABBWrapper.java @@ -0,0 +1,44 @@ +package com.alrex.parcool.compatibility; + +import net.minecraft.util.math.AxisAlignedBB; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.vector.Vector3d; + +public class AABBWrapper extends AxisAlignedBB { + public AABBWrapper(BlockPos blockPos) { + super(blockPos); + } + + public AABBWrapper(double minX, double minY, double minZ, double maxX, double maxY, double maxZ) { + super(minX, minY, minZ, maxX, maxY, maxZ); + } + + public AABBWrapper(Vec3Wrapper subtract, Vec3Wrapper vec3Wrapper) { + super(subtract, vec3Wrapper); + } + + @Override + public AABBWrapper expandTowards(Vector3d vec) { + return get(super.expandTowards(vec)); + } + + @Override + public AABBWrapper expandTowards(double x, double y, double z) { + return get(super.expandTowards(x, y, z)); + } + + @Override + public AABBWrapper inflate(double p_186662_1_) { + return get(super.inflate(p_186662_1_)); + } + + @Override + public AABBWrapper inflate(double p_72314_1_, double p_72314_3_, double p_72314_5_) { + return get(super.inflate(p_72314_1_, p_72314_3_, p_72314_5_)); + } + + public static AABBWrapper get(AxisAlignedBB boundingBox) { + return new AABBWrapper(boundingBox.minX, boundingBox.minY, boundingBox.minZ, + boundingBox.maxX, boundingBox.maxY, boundingBox.maxZ); + } +} diff --git a/src/main/java/com/alrex/parcool/compatibility/AxisWrapper.java b/src/main/java/com/alrex/parcool/compatibility/AxisWrapper.java index 17fb5e76..4ed2e3b2 100644 --- a/src/main/java/com/alrex/parcool/compatibility/AxisWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/AxisWrapper.java @@ -35,7 +35,7 @@ public Quaternion rotation(float angle) { } public static AxisWrapper fromVector(Vec3Wrapper midPointD) { - return new AxisWrapper(midPointD.x(), midPointD.y(), midPointD.z()); + return new AxisWrapper(midPointD.getX(), midPointD.getY(), midPointD.getZ()); } public float x() { diff --git a/src/main/java/com/alrex/parcool/compatibility/BlockEntityWrapper.java b/src/main/java/com/alrex/parcool/compatibility/BlockEntityWrapper.java index 2d0cd3ee..4acf4549 100644 --- a/src/main/java/com/alrex/parcool/compatibility/BlockEntityWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/BlockEntityWrapper.java @@ -1,5 +1,7 @@ package com.alrex.parcool.compatibility; +import com.alrex.parcool.common.block.zipline.ZiplineHookTileEntity; + import net.minecraft.tileentity.TileEntity; public class BlockEntityWrapper { @@ -13,4 +15,12 @@ public BlockEntityWrapper(TileEntity blockEntity) { public T cast(Class classTarget) { return classTarget.isInstance(blockEntity) ? (T) blockEntity : null; } + + public boolean is(Class class1) { + return class1.isInstance(blockEntity); + } + + public TileEntity getInstance() { + return blockEntity; + } } diff --git a/src/main/java/com/alrex/parcool/compatibility/BlockStateWrapper.java b/src/main/java/com/alrex/parcool/compatibility/BlockStateWrapper.java new file mode 100644 index 00000000..ffb6dcf4 --- /dev/null +++ b/src/main/java/com/alrex/parcool/compatibility/BlockStateWrapper.java @@ -0,0 +1,90 @@ +package com.alrex.parcool.compatibility; + +import com.alrex.parcool.common.tags.BlockTags; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockRenderType; +import net.minecraft.block.BlockState; +import net.minecraft.block.SoundType; +import net.minecraft.client.Minecraft; +import net.minecraft.entity.Entity; +import net.minecraft.particles.BlockParticleData; +import net.minecraft.particles.IParticleData; +import net.minecraft.particles.ParticleType; +import net.minecraft.particles.ParticleTypes; +import net.minecraft.state.DirectionProperty; +import net.minecraft.state.Property; +import net.minecraft.util.Direction; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.IWorldReader; +import net.minecraft.world.World; + +public class BlockStateWrapper { + public static final Minecraft mc = Minecraft.getInstance(); + private final BlockState block; + + public BlockStateWrapper(BlockState block) { + this.block = block; + } + + public float getFriction(IWorldReader world, BlockPos pos, Entity entity) { + return block.getSlipperiness(world, pos, entity); + } + + public BlockState getInstance() { + return block; + } + + public SoundType getSoundType() { + return block.getSoundType(); + } + + public Block getBlock() { + return block.getBlock(); + } + + public boolean isCollisionShapeFullBlock(World world, BlockPos pos) { + return block.isCollisionShapeFullBlock(world, pos); + } + + public > T getValue(Property axis) { + return block.getValue(axis); + } + + public Direction getValue(DirectionProperty facing) { + return block.getValue(facing); + } + + public BlockState getBlockState() { + return block.getBlockState(); + } + + public static BlockStateWrapper get(BlockState stateBase) { + return new BlockStateWrapper(stateBase); + } + + public boolean is(Block block2) { + return block.getBlock() == block2; + } + + public boolean isAir() { + return block.isAir(); + } + + public BlockRenderType getRenderShape() { + // TODO Auto-generated method stub + throw new UnsupportedOperationException("Unimplemented method 'getRenderShape'"); + } + + public boolean isHideAbleBlock() { + return block.getBlock().getTags().contains(BlockTags.HIDE_ABLE); + } + + public IParticleData getBlockParticleData(ParticleType block2, BlockPos blockpos) { + return new BlockParticleData(ParticleTypes.BLOCK, block).setPos(blockpos); + } + + public void destroyParticle(BlockPos pos) { + mc.particleEngine.destroy(pos, block); + } +} diff --git a/src/main/java/com/alrex/parcool/compatibility/EntityWrapper.java b/src/main/java/com/alrex/parcool/compatibility/EntityWrapper.java index 1f74ae33..9033283f 100644 --- a/src/main/java/com/alrex/parcool/compatibility/EntityWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/EntityWrapper.java @@ -7,13 +7,13 @@ import javax.annotation.Nullable; import com.alrex.parcool.client.animation.PlayerModelRotator; +import com.alrex.parcool.utilities.MathUtil; + import net.minecraft.block.BlockState; import net.minecraft.entity.Entity; import net.minecraft.particles.BasicParticleType; import net.minecraft.util.SoundEvent; -import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.MathHelper; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.common.util.LazyOptional; @@ -62,8 +62,8 @@ public float getBbWidth() { return entityRef.get().getBbWidth(); } - public BlockState getBlockState(BlockPos pos) { - return entityRef.get().level.getBlockState(pos); + public BlockStateWrapper getBlockState(BlockPos pos) { + return new BlockStateWrapper(entityRef.get().level.getBlockState(pos)); } @Nullable @@ -96,9 +96,10 @@ public Vec3Wrapper getLookAngle() { public float getMinSlipperiness(BlockPos ...blockPos) { float minSlipperiness = 1; Entity entity = entityRef.get(); + LevelWrapper level = getLevel(); for (BlockPos pos : blockPos) { - if (entity.level.isLoaded(pos)) { - float candidateSlipperiness = entity.level.getBlockState(pos).getSlipperiness(entity.level, pos, entity); + if (level.isLoaded(pos)) { + float candidateSlipperiness = level.getBlockState(pos).getFriction(entity.level, pos, entity); minSlipperiness = Math.min(minSlipperiness, candidateSlipperiness); } } @@ -106,7 +107,7 @@ public float getMinSlipperiness(BlockPos ...blockPos) { } public float getRotatedYRot(PlayerModelRotator rotator) { - return 180f + MathHelper.lerp(rotator.getPartialTick(), entityRef.get().yRotO, entityRef.get().yRot); + return 180f + MathUtil.lerp(rotator.getPartialTick(), entityRef.get().yRotO, entityRef.get().yRot); } public int getTickCount() { @@ -181,7 +182,7 @@ public void multiplyDeltaMovement(double d, int i, double e) { entity.setDeltaMovement(entity.getDeltaMovement().multiply(d, i, e)); } - public boolean noCollision(AxisAlignedBB bb) { + public boolean noCollision(AABBWrapper bb) { return entityRef.get().level.noCollision(bb); } diff --git a/src/main/java/com/alrex/parcool/compatibility/LevelWrapper.java b/src/main/java/com/alrex/parcool/compatibility/LevelWrapper.java index 25b26c1a..f0af66bd 100644 --- a/src/main/java/com/alrex/parcool/compatibility/LevelWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/LevelWrapper.java @@ -8,6 +8,7 @@ import net.minecraft.block.BlockState; import net.minecraft.client.Minecraft; +import net.minecraft.entity.Entity; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.particles.IParticleData; import net.minecraft.util.math.AxisAlignedBB; @@ -15,12 +16,12 @@ import net.minecraft.world.World; public final class LevelWrapper { - private WeakReference level; + private WeakReference levelRef; private static final WeakCache cache = new WeakCache<>(); private static final Minecraft mc = Minecraft.getInstance(); public LevelWrapper(World level) { - this.level = new WeakReference<>(level); + this.levelRef = new WeakReference<>(level); } public static LevelWrapper get(World level) { @@ -28,47 +29,64 @@ public static LevelWrapper get(World level) { } public PlayerEntity getPlayerByUUID(UUID playerID) { - return level.get().getPlayerByUUID(playerID); + return levelRef.get().getPlayerByUUID(playerID); } public void addParticle(IParticleData drippingWater, double d, double e, double f, double x, double g, double z) { - level.get().addParticle(drippingWater, d, e, f, x, g, z); + levelRef.get().addParticle(drippingWater, d, e, f, x, g, z); } public boolean isLoaded(BlockPos blockpos) { - return level.get().isLoaded(blockpos); + return levelRef.get().isLoaded(blockpos); } - public BlockState getBlockState(BlockPos blockpos) { - return level.get().getBlockState(blockpos); + public BlockStateWrapper getBlockState(BlockPos blockpos) { + return BlockStateWrapper.get(levelRef.get().getBlockState(blockpos)); } public boolean isClientSide() { - return level.get().isClientSide(); + return levelRef.get().isClientSide(); } public BlockEntityWrapper getBlockEntity(BlockPos pos) { - return new BlockEntityWrapper(level.get().getBlockEntity(pos)); + return new BlockEntityWrapper(levelRef.get().getBlockEntity(pos)); } public static LevelWrapper get() { return get(mc.level); } - public boolean isCollisionShapeFullBlock(BlockState state, BlockPos pos) { - return state.isCollisionShapeFullBlock(level.get(), pos); + public boolean isCollisionShapeFullBlock(BlockStateWrapper state, BlockPos pos) { + return state.getInstance().isCollisionShapeFullBlock(levelRef.get(), pos); } - public boolean noCollision(AxisAlignedBB expandTowards) { - return level.get().noCollision(expandTowards); + public boolean noCollision(AABBWrapper expandTowards) { + return levelRef.get().noCollision(expandTowards); } - public List getEntitiesOfClass(Class class1, AxisAlignedBB inflate) { - return level.get().getEntitiesOfClass(class1, inflate); + public List getEntitiesOfClass(Class class1, AABBWrapper inflate) { + return levelRef.get().getEntitiesOfClass(class1, inflate); } public World getInstance() { - return level.get(); + return levelRef.get(); + } + + public boolean isCollisionShapeFullBlock(BlockState state, BlockPos pos) { + return state.isCollisionShapeFullBlock(levelRef.get(), pos); + } + + public boolean addFreshEntity(ZiplineRopeEntity entity) { + return levelRef.get().addFreshEntity(entity); + } + + public boolean isAir(BlockPos block) { + return getBlockState(block).isAir(); + } + + public float getSlipperiness(BlockPos leanedBlock, Entity entity) { + World level = levelRef.get(); + return level.getBlockState(leanedBlock).getSlipperiness(level, leanedBlock, entity); } } diff --git a/src/main/java/com/alrex/parcool/compatibility/LivingEntityWrapper.java b/src/main/java/com/alrex/parcool/compatibility/LivingEntityWrapper.java index 42c415e6..4f306bfb 100644 --- a/src/main/java/com/alrex/parcool/compatibility/LivingEntityWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/LivingEntityWrapper.java @@ -42,8 +42,8 @@ public double getAttributeValue(Attribute attribute) { return entityRef.get().getAttributeValue(attribute); } - public AxisAlignedBB getBoundingBox() { - return entityRef.get().getBoundingBox(); + public AABBWrapper getBoundingBox() { + return AABBWrapper.get(entityRef.get().getBoundingBox()); } public double getGravity() { diff --git a/src/main/java/com/alrex/parcool/compatibility/MinecraftServerWrapper.java b/src/main/java/com/alrex/parcool/compatibility/MinecraftServerWrapper.java index 5cd73314..e8a4543f 100644 --- a/src/main/java/com/alrex/parcool/compatibility/MinecraftServerWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/MinecraftServerWrapper.java @@ -66,8 +66,8 @@ public ServerPlayerWrapper next() { }; } - public static Iterable getPlayers(Iterable iterable) { - Iterator iterator = iterable.iterator(); + public static Iterable getPlayers(Iterable iterable) { + Iterator iterator = iterable.iterator(); return new Iterable() { @Override public Iterator iterator() { diff --git a/src/main/java/com/alrex/parcool/compatibility/NetworkContextWrapper.java b/src/main/java/com/alrex/parcool/compatibility/NetworkContextWrapper.java new file mode 100644 index 00000000..6f2b4e59 --- /dev/null +++ b/src/main/java/com/alrex/parcool/compatibility/NetworkContextWrapper.java @@ -0,0 +1,40 @@ +package com.alrex.parcool.compatibility; + +import java.util.function.Supplier; + +import net.minecraft.entity.player.ServerPlayerEntity; +import net.minecraft.network.PacketDirection; +import net.minecraftforge.fml.LogicalSide; +import net.minecraftforge.fml.network.NetworkEvent.Context; + +public class NetworkContextWrapper { + private Context context; + + private NetworkContextWrapper(Context context) { + this.context = context; + } + + public ServerPlayerEntity getSender() { + return context.getSender(); + } + + public static Supplier getSupplier(Supplier contextSupplier) { + return () -> new NetworkContextWrapper(contextSupplier.get()); + } + + public void enqueueWork(Runnable runnable) { + context.enqueueWork(runnable); + } + + public LogicalSide getReceptionSide() { + return context.getDirection().getReceptionSide(); + } + + public void setPacketHandled(boolean b) { + context.setPacketHandled(b); + } + + public PacketDirection getDirection() { + return context.getNetworkManager().getDirection(); + } +} diff --git a/src/main/java/com/alrex/parcool/compatibility/PlayerWrapper.java b/src/main/java/com/alrex/parcool/compatibility/PlayerWrapper.java index 7abf4b0f..27391452 100644 --- a/src/main/java/com/alrex/parcool/compatibility/PlayerWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/PlayerWrapper.java @@ -45,9 +45,9 @@ public PlayerEntity getInstance() { return playerRef.get(); } - public BlockState getBelowBlockState() { + public BlockStateWrapper getBelowBlockState() { PlayerEntity player = playerRef.get(); - return player.level.getBlockState(player.blockPosition().below()); + return new BlockStateWrapper(player.level.getBlockState(player.blockPosition().below())); } public float getEyeHeight() { @@ -75,8 +75,8 @@ public Pose getPose() { } public float getSlipperiness(BlockPos leanedBlock) { - PlayerEntity player = playerRef.get(); - return player.level.getBlockState(leanedBlock).getSlipperiness(player.level, leanedBlock, player); + LevelWrapper level = getLevel(); + return level.getSlipperiness(leanedBlock, playerRef.get()); } public int getTickCount() { @@ -128,7 +128,7 @@ public static PlayerWrapper get(CapabilityProvider entityMixin) { return get((PlayerEntity)(Object)entityMixin); } - public static PlayerWrapper get(Supplier contextSupplier) { + public static PlayerWrapper get(Supplier contextSupplier) { return get(contextSupplier.get().getSender()); } diff --git a/src/main/java/com/alrex/parcool/compatibility/ServerEventWrapper.java b/src/main/java/com/alrex/parcool/compatibility/ServerEventWrapper.java new file mode 100644 index 00000000..f31fb2ca --- /dev/null +++ b/src/main/java/com/alrex/parcool/compatibility/ServerEventWrapper.java @@ -0,0 +1,17 @@ +package com.alrex.parcool.compatibility; + +import net.minecraft.server.MinecraftServer; +import net.minecraftforge.eventbus.api.Event; +import net.minecraftforge.fml.event.server.ServerLifecycleEvent; + +public class ServerEventWrapper { + private ServerLifecycleEvent event; + + public ServerEventWrapper(Event event) { + this.event = (ServerLifecycleEvent)event; + } + + public MinecraftServer getServer() { + return event.getServer(); + } +} diff --git a/src/main/java/com/alrex/parcool/compatibility/ServerPlayerWrapper.java b/src/main/java/com/alrex/parcool/compatibility/ServerPlayerWrapper.java index f731a65f..9046712c 100644 --- a/src/main/java/com/alrex/parcool/compatibility/ServerPlayerWrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/ServerPlayerWrapper.java @@ -28,7 +28,7 @@ public static ServerPlayerWrapper get(ServerPlayerEntity player) { return cache.get(player, () -> new ServerPlayerWrapper(player)); } - public static ServerPlayerWrapper get(Supplier contextSupplier) { + public static ServerPlayerWrapper get(Supplier contextSupplier) { return new ServerPlayerWrapper(contextSupplier.get().getSender()); } diff --git a/src/main/java/com/alrex/parcool/compatibility/Vec3Wrapper.java b/src/main/java/com/alrex/parcool/compatibility/Vec3Wrapper.java index bdcf9b22..7ab42ae9 100644 --- a/src/main/java/com/alrex/parcool/compatibility/Vec3Wrapper.java +++ b/src/main/java/com/alrex/parcool/compatibility/Vec3Wrapper.java @@ -1,6 +1,5 @@ package com.alrex.parcool.compatibility; -import com.alrex.parcool.utilities.VectorUtil; import net.minecraft.util.math.vector.Vector3d; public class Vec3Wrapper extends Vector3d { @@ -63,4 +62,16 @@ public Vec3Wrapper yRot(float value) { public Vec3Wrapper reverse() { return new Vec3Wrapper(super.reverse()); } + + public double getX() { + return super.x(); + } + + public double getY() { + return super.y(); + } + + public double getZ() { + return super.z(); + } } diff --git a/src/main/java/com/alrex/parcool/compatibility/WeakCache.java b/src/main/java/com/alrex/parcool/compatibility/WeakCache.java index eb4d9278..15cd1ae3 100644 --- a/src/main/java/com/alrex/parcool/compatibility/WeakCache.java +++ b/src/main/java/com/alrex/parcool/compatibility/WeakCache.java @@ -2,8 +2,7 @@ import java.util.Map; import java.util.WeakHashMap; - -import com.google.common.base.Supplier; +import java.util.function.Supplier; public class WeakCache { private final Map, WeakHashMap> cache = new WeakHashMap<>(); diff --git a/src/main/java/com/alrex/parcool/mixin/common/LivingEntityMixin.java b/src/main/java/com/alrex/parcool/mixin/common/LivingEntityMixin.java index 47b1cead..4872cc07 100644 --- a/src/main/java/com/alrex/parcool/mixin/common/LivingEntityMixin.java +++ b/src/main/java/com/alrex/parcool/mixin/common/LivingEntityMixin.java @@ -4,6 +4,7 @@ import com.alrex.parcool.common.action.impl.ClimbPoles; import com.alrex.parcool.common.action.impl.ClimbUp; import com.alrex.parcool.common.capability.Parkourability; +import com.alrex.parcool.compatibility.BlockStateWrapper; import com.alrex.parcool.compatibility.EventBusWrapper; import com.alrex.parcool.compatibility.LevelWrapper; import com.alrex.parcool.compatibility.LivingEntityWrapper; @@ -78,8 +79,9 @@ public void onClimbable(CallbackInfoReturnable cir) { } @Unique - public boolean parCool$isLivingOnCustomLadder(@Nonnull BlockState state, @Nonnull LevelWrapper world, @Nonnull BlockPos pos, @Nonnull LivingEntityWrapper entity) { + public boolean parCool$isLivingOnCustomLadder(@Nonnull BlockState stateBase, @Nonnull LevelWrapper world, @Nonnull BlockPos pos, @Nonnull LivingEntityWrapper entity) { boolean isSpectator = PlayerWrapper.is(entity) && entity.isSpectator(); + BlockStateWrapper state = BlockStateWrapper.get(stateBase); if (isSpectator) return false; if (!ForgeConfig.SERVER.fullBoundingBoxLadders.get()) { return parCool$isCustomLadder(state, world, pos, entity); @@ -107,7 +109,7 @@ public void onClimbable(CallbackInfoReturnable cir) { } @Unique - private boolean parCool$isCustomLadder(BlockState state, LevelWrapper level, BlockPos pos, LivingEntityWrapper entity) { + private boolean parCool$isCustomLadder(BlockStateWrapper state, LevelWrapper level, BlockPos pos, LivingEntityWrapper entity) { Block block = state.getBlockState().getBlock(); if (block instanceof FourWayBlock) { int zCount = 0; diff --git a/src/main/java/com/alrex/parcool/server/limitation/Limitations.java b/src/main/java/com/alrex/parcool/server/limitation/Limitations.java index 86c28ab0..906b7494 100644 --- a/src/main/java/com/alrex/parcool/server/limitation/Limitations.java +++ b/src/main/java/com/alrex/parcool/server/limitation/Limitations.java @@ -6,11 +6,10 @@ import com.alrex.parcool.common.info.ServerLimitation; import com.alrex.parcool.common.network.SyncServerInfoMessage; import com.alrex.parcool.compatibility.ServerPlayerWrapper; +import com.alrex.parcool.compatibility.ServerEventWrapper; import com.alrex.parcool.utilities.JsonWriterUtil; import com.alrex.parcool.utilities.ServerUtil; import com.google.gson.stream.JsonReader; -import net.minecraftforge.fml.event.server.FMLServerAboutToStartEvent; -import net.minecraftforge.fml.event.server.FMLServerStoppingEvent; import org.apache.commons.io.FileUtils; import javax.annotation.Nullable; import java.io.*; @@ -180,7 +179,7 @@ public static void unload(UUID playerID) { ParCool.LOGGER.info("Limitation of " + playerID + " was unloaded"); } - public static void init(FMLServerAboutToStartEvent event) { + public static void init(ServerEventWrapper event) { GlobalLimitation.readFromServerConfig(); Path configPath = ServerUtil.getServerConfigPath(event.getServer()); LimitationFolderRootPath = configPath.resolve("parcool").resolve("limitations"); @@ -190,7 +189,7 @@ public static void init(FMLServerAboutToStartEvent event) { } } - public static void save(FMLServerStoppingEvent event) { + public static void save(ServerEventWrapper event) { Path configPath = ServerUtil.getServerConfigPath(event.getServer()); Path limitationRootPath = configPath.resolve("parcool").resolve("limitations"); for (Map.Entry> limitationEntry : Loaded.entrySet()) { diff --git a/src/main/java/com/alrex/parcool/utilities/WorldUtil.java b/src/main/java/com/alrex/parcool/utilities/WorldUtil.java index f755d1dd..02e57957 100644 --- a/src/main/java/com/alrex/parcool/utilities/WorldUtil.java +++ b/src/main/java/com/alrex/parcool/utilities/WorldUtil.java @@ -2,16 +2,16 @@ import com.alrex.parcool.common.action.impl.HangDown; import com.alrex.parcool.common.tags.BlockTags; +import com.alrex.parcool.compatibility.AABBWrapper; +import com.alrex.parcool.compatibility.BlockStateWrapper; import com.alrex.parcool.compatibility.EntityWrapper; import com.alrex.parcool.compatibility.LevelWrapper; import com.alrex.parcool.compatibility.LivingEntityWrapper; import com.alrex.parcool.compatibility.Vec3Wrapper; - import net.minecraft.block.*; import net.minecraft.state.properties.Half; import net.minecraft.util.Direction; import net.minecraft.util.Tuple; -import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; import javax.annotation.Nullable; @@ -24,7 +24,7 @@ public static Vec3Wrapper getRunnableWall(LivingEntityWrapper entity, double ran double wallZ = 0; Vec3Wrapper pos = entity.position(); - AxisAlignedBB baseBox1 = new AxisAlignedBB( + AABBWrapper baseBox1 = new AABBWrapper( pos.x() - width, pos.y(), pos.z() - width, @@ -32,7 +32,7 @@ public static Vec3Wrapper getRunnableWall(LivingEntityWrapper entity, double ran pos.y() + entity.getBbHeight() / 1.63, pos.z() + width ); - AxisAlignedBB baseBox2 = new AxisAlignedBB( + AABBWrapper baseBox2 = new AABBWrapper( pos.x() - width, pos.y() + entity.getBbHeight() / 1.63, pos.z() - width, @@ -77,7 +77,7 @@ public static Vec3Wrapper getWall(LivingEntityWrapper entity, double range) { double wallZ = 0; Vec3Wrapper pos = entity.position(); - AxisAlignedBB baseBox = new AxisAlignedBB( + AABBWrapper baseBox = new AABBWrapper( pos.x() - width, pos.y(), pos.z() - width, @@ -113,7 +113,7 @@ public static Vec3Wrapper getVaultableStep(LivingEntityWrapper entity) { double stepZ = 0; Vec3Wrapper pos = entity.position(); - AxisAlignedBB baseBoxBottom = new AxisAlignedBB( + AABBWrapper baseBoxBottom = new AABBWrapper( pos.x() - d, pos.y(), pos.z() - d, @@ -121,7 +121,7 @@ public static Vec3Wrapper getVaultableStep(LivingEntityWrapper entity) { pos.y() + baseLine, pos.z() + d ); - AxisAlignedBB baseBoxTop = new AxisAlignedBB( + AABBWrapper baseBoxTop = new AABBWrapper( pos.x() - d, pos.y() + baseLine, pos.z() - d, @@ -146,7 +146,7 @@ public static Vec3Wrapper getVaultableStep(LivingEntityWrapper entity) { Vec3Wrapper result = new Vec3Wrapper(stepX, 0, stepZ); BlockPos target = new BlockPos(entity.position().add(result).add(0, 0.5, 0)); if (!world.isLoaded(target)) return null; - BlockState state = world.getBlockState(target); + BlockStateWrapper state = world.getBlockState(target); if (state.getBlock() instanceof StairsBlock) { Half half = state.getValue(StairsBlock.HALF); if (half != Half.BOTTOM) return result; @@ -168,7 +168,7 @@ public static double getWallHeight(LivingEntityWrapper entity, Vec3Wrapper direc Vec3Wrapper pos = entity.position(); boolean canReturn = false; for (double height = 0; height < maxHeight; height += accuracy) { - AxisAlignedBB box = new AxisAlignedBB( + AABBWrapper box = new AABBWrapper( pos.x() + d + (direction.x() > 0 ? 1 : 0), pos.y() + height, pos.z() + d + (direction.z() > 0 ? 1 : 0), @@ -197,7 +197,7 @@ public static double getWallHeight(LivingEntityWrapper entity) { Vec3Wrapper pos = entity.position(); boolean canReturn = false; for (int i = 0; i < loopNum; i++) { - AxisAlignedBB box = new AxisAlignedBB( + AABBWrapper box = new AABBWrapper( pos.x() + d + (wall.x() > 0 ? 1 : 0), pos.y() + accuracy * i, pos.z() + d + (wall.z() > 0 ? 1 : 0), @@ -222,7 +222,7 @@ public static HangDown.BarAxis getHangableBars(LivingEntityWrapper entity) { double x = entity.getX(); double y = entity.getY(); double z = entity.getZ(); - AxisAlignedBB bb = new AxisAlignedBB( + AABBWrapper bb = new AABBWrapper( x - bbWidth, y + entity.getBbHeight(), z - bbWidth, @@ -237,7 +237,7 @@ public static HangDown.BarAxis getHangableBars(LivingEntityWrapper entity) { z ); if (!entity.isEveryLoaded(pos)) return null; - BlockState state = entity.getBlockState(pos); + BlockStateWrapper state = entity.getBlockState(pos); Block block = state.getBlock(); HangDown.BarAxis axis = null; if (block instanceof RotatedPillarBlock) { @@ -296,7 +296,7 @@ public static boolean existsSpaceBelow(LivingEntityWrapper entity) { if (!world.isLoaded(new BlockPos(center))) return false; double height = entity.getBbHeight() * 1.5; double width = entity.getBbWidth() * 2; - AxisAlignedBB boundingBox = new AxisAlignedBB( + AABBWrapper boundingBox = new AABBWrapper( center.x() - width, center.y() - 9, center.z() - width, @@ -316,7 +316,7 @@ public static boolean existsDivableSpace(LivingEntityWrapper entity) { Vec3Wrapper diveDirection = VectorUtil.fromYawDegree(entity.getYHeadRot()); for (int i = 0; i < 4; i++) { Vec3Wrapper centerPoint = center.add(diveDirection.scale(width * i)); - AxisAlignedBB box = new AxisAlignedBB( + AABBWrapper box = new AABBWrapper( centerPoint.x() - width, centerPoint.y() + 0.05, centerPoint.z() - width, @@ -327,7 +327,7 @@ public static boolean existsDivableSpace(LivingEntityWrapper entity) { if (!world.noCollision(box)) return false; } center = center.add(diveDirection.scale(4)); - AxisAlignedBB verticalWideBox = new AxisAlignedBB( + AABBWrapper verticalWideBox = new AABBWrapper( center.x() - wideWidth, center.y() - 9, center.z() - wideWidth, @@ -340,7 +340,7 @@ public static boolean existsDivableSpace(LivingEntityWrapper entity) { // check if water pool exists if (!world.isLoaded(centerBlockPos)) return false; - verticalWideBox = new AxisAlignedBB( + verticalWideBox = new AABBWrapper( center.x() - wideWidth, center.y() - 2.9, center.z() - wideWidth, @@ -362,7 +362,7 @@ public static boolean existsDivableSpace(LivingEntityWrapper entity) { if (waterLevel == -1) return false; boolean filledWithWater = true; for (; i < waterLevel + 3; i++) { - BlockState state = world.getBlockState(centerBlockPos.below(i)); + BlockStateWrapper state = world.getBlockState(centerBlockPos.below(i)); if (state.getBlock() != Blocks.WATER) { filledWithWater = false; break; @@ -387,7 +387,7 @@ private static Vec3Wrapper getGrabbableWall(LivingEntityWrapper entity, double d final double d = entity.getBbWidth() * 0.49; LevelWrapper world = entity.getLevel(); Vec3Wrapper pos = entity.position(); - AxisAlignedBB baseBoxSide = new AxisAlignedBB( + AABBWrapper baseBoxSide = new AABBWrapper( pos.x() - d, pos.y() + baseLine - entity.getBbHeight() / 6, pos.z() - d, @@ -395,7 +395,7 @@ private static Vec3Wrapper getGrabbableWall(LivingEntityWrapper entity, double d pos.y() + baseLine, pos.z() + d ); - AxisAlignedBB baseBoxTop = new AxisAlignedBB( + AABBWrapper baseBoxTop = new AABBWrapper( pos.x() - d, pos.y() + baseLine, pos.z() - d, @@ -443,22 +443,18 @@ private static Vec3Wrapper getGrabbableWall(LivingEntityWrapper entity, double d return slipperiness <= 0.9 ? new Vec3Wrapper(xDirection, 0, zDirection) : null; } - public static boolean isHideAbleBlock(BlockState blockState) { - return blockState.getBlock().getTags().contains(BlockTags.HIDE_ABLE); - } - private static boolean getHideAbleSpace$isHideAble(LevelWrapper world, Block block, BlockPos pos) { - return world.isLoaded(pos) && world.getBlockState(pos).is(block) && world.getBlockState(pos.above()).isAir(); + return world.isLoaded(pos) && world.getBlockState(pos).is(block) && world.isAir(pos.above()); } @Nullable public static Tuple getHideAbleSpace(EntityWrapper entity, BlockPos base) { LevelWrapper world = entity.getLevel(); if (!world.isLoaded(base)) return null; - BlockState state = world.getBlockState(base); + BlockStateWrapper state = world.getBlockState(base); Block block = state.getBlock(); - if (!isHideAbleBlock(state)) return null; - if (!world.getBlockState(base.above()).isAir()) { + if (!state.isHideAbleBlock()) return null; + if (!world.isAir(base.above())) { if (getHideAbleSpace$isHideAble(world, block, base.above())) { return new Tuple<>(base, base.above()); }