path: root/src/main/java/de/hysky/skyblocker/skyblock/SmoothAOTE.java

package de.hysky.skyblocker.skyblock;

import de.hysky.skyblocker.annotations.Init;
import de.hysky.skyblocker.config.SkyblockerConfigManager;
import de.hysky.skyblocker.skyblock.dungeon.DungeonBoss;
import de.hysky.skyblocker.skyblock.dungeon.secrets.DungeonManager;
import de.hysky.skyblocker.utils.ItemUtils;
import de.hysky.skyblocker.utils.Location;
import de.hysky.skyblocker.utils.Utils;
import net.fabricmc.fabric.api.event.player.UseBlockCallback;
import net.fabricmc.fabric.api.event.player.UseItemCallback;
import net.minecraft.block.*;
import net.minecraft.client.MinecraftClient;
import net.minecraft.client.option.Perspective;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.item.ItemStack;
import net.minecraft.item.Items;
import net.minecraft.nbt.NbtCompound;
import net.minecraft.state.property.Properties;
import net.minecraft.util.ActionResult;
import net.minecraft.util.Hand;
import net.minecraft.util.hit.BlockHitResult;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Vec3d;
import net.minecraft.util.shape.VoxelShape;
import net.minecraft.world.World;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class SmoothAOTE {

	private static final MinecraftClient CLIENT = MinecraftClient.getInstance();

	private static final Pattern MANA_LORE = Pattern.compile("Mana Cost: (\\d+)");
	private static final long MAX_TELEPORT_TIME = 2500; //2.5 seconds

	private static long startTime;
	private static Vec3d startPos;
	private static Vec3d cameraStartPos;
	private static Vec3d teleportVector;
	private static long lastPing;
	private static long currentTeleportPing;
	private static int teleportsAhead;
	private static long lastTeleportTime;
	public static boolean teleportDisabled;

	@Init
	public static void init() {
		UseItemCallback.EVENT.register(SmoothAOTE::onItemInteract);
		UseBlockCallback.EVENT.register(SmoothAOTE::onBlockInteract);
	}

	/**
	 * When a player receives a teleport packet finish a teleport
	 */
	public static void playerTeleported() {
		//the player has been teleported so 1 less teleport ahead
		teleportsAhead = Math.max(0, teleportsAhead - 1);
		//re-enable the animation if the player is teleported as this means they can teleport again. and reset timer for last teleport update
		lastTeleportTime = System.currentTimeMillis();
		teleportDisabled = false;

		//if the server is in sync in number of teleports
		if (teleportsAhead == 0) {
			//see if the teleport has a small amount left to continue animating instead of jumping to the end
			long timeLeft = (currentTeleportPing - (System.currentTimeMillis() - startTime));
			if (timeLeft > 0 && timeLeft <= SkyblockerConfigManager.get().uiAndVisuals.smoothAOTE.maximumAddedLag) {
				return;
			}
			//reset when player has reached the end of the teleports
			startPos = null;
			teleportVector = null;

		}
	}

	/**
	 * checks to see if a teleport device is using transmission tuner to increase the range
	 *
	 * @param customData the custom data of the teleport device
	 * @param baseRange  the base range for the device without tuner
	 * @return the range with tuner
	 */
	private static int extractTunedCustomData(NbtCompound customData, int baseRange) {
		return customData != null && customData.contains("tuned_transmission") ? baseRange + customData.getInt("tuned_transmission", 0) : baseRange;
	}

	/**
	 * When an item is right-clicked send off to calculate teleport with the clicked item
	 *
	 * @param playerEntity player
	 * @param world        world
	 * @param hand         held item
	 * @return pass
	 */
	private static ActionResult onItemInteract(PlayerEntity playerEntity, World world, Hand hand) {
		if (CLIENT.player == null) {
			return null;
		}
		calculateTeleportUse(hand);
		return ActionResult.PASS;
	}

	/**
	 * Allows shovel teleport items to be used when aiming at interactable blocks
	 *
	 * @param playerEntity   player
	 * @param world          world
	 * @param hand           hand item
	 * @param blockHitResult target block
	 * @return always pass
	 */
	private static ActionResult onBlockInteract(PlayerEntity playerEntity, World world, Hand hand, BlockHitResult blockHitResult) {
		ItemStack itemStack = playerEntity.getStackInHand(hand);
		if (isShovel(itemStack) && canShovelActOnBlock(world.getBlockState(blockHitResult.getBlockPos()).getBlock())) {
			calculateTeleportUse(hand);
		}
		return ActionResult.PASS;
	}

	private static boolean isShovel(ItemStack itemStack) {
		return itemStack.isOf(Items.WOODEN_SHOVEL) ||
				itemStack.isOf(Items.STONE_SHOVEL) ||
				itemStack.isOf(Items.IRON_SHOVEL) ||
				itemStack.isOf(Items.GOLDEN_SHOVEL) ||
				itemStack.isOf(Items.DIAMOND_SHOVEL);
	}

	/**
	 * Checks if the block is one that the shovel can turn into a path (e.g., grass or dirt)
	 *
	 * @param block block to check
	 * @return if block can be turned into path
	 */
	private static boolean canShovelActOnBlock(Block block) {
		return block == Blocks.GRASS_BLOCK ||
				block == Blocks.DIRT ||
				block == Blocks.COARSE_DIRT ||
				block == Blocks.PODZOL;
	}

	/**
	 * Finds if a player uses a teleport and then saves the start position and time. then works out final position and saves that too
	 *
	 * @param hand what the player is holding
	 */

	private static void calculateTeleportUse(Hand hand) {
		//stop checking if player does not exist
		if (CLIENT.player == null || CLIENT.world == null) {
			return;
		}
		//get return item
		ItemStack stack = CLIENT.player.getStackInHand(hand);

		//make sure it's not disabled
		if (teleportDisabled) {
			return;
		}

		// make sure the camera is not in 3rd person
		if (CLIENT.options.getPerspective() != Perspective.FIRST_PERSON) {
			return;
		}

		//make sure the player is in an area teleporting is allowed not allowed in glacite mineshafts and floor 7 boss
		if (!isAllowedLocation()) {
			return;
		}

		//work out if the player is holding a teleporting item that is enabled and if so how far the item will take them
		ItemStack heldItem = CLIENT.player.getMainHandStack();
		String itemId = heldItem.getSkyblockId();
		NbtCompound customData = ItemUtils.getCustomData(heldItem);

		int distance;
		switch (itemId) {
			case "ASPECT_OF_THE_LEECH_1" -> {
				if (SkyblockerConfigManager.get().uiAndVisuals.smoothAOTE.enableWeirdTransmission) {
					distance = 3;
					break;
				}
				return;

			}
			case "ASPECT_OF_THE_LEECH_2" -> {
				if (SkyblockerConfigManager.get().uiAndVisuals.smoothAOTE.enableWeirdTransmission) {
					distance = 4;
					break;
				}
				return;
			}
			case "ASPECT_OF_THE_END", "ASPECT_OF_THE_VOID" -> {
				if (CLIENT.options.sneakKey.isPressed() && customData.getInt("ethermerge", 0) == 1) {
					if (SkyblockerConfigManager.get().uiAndVisuals.smoothAOTE.enableEtherTransmission) {
						distance = extractTunedCustomData(customData, 57);
						break;
					}
				} else if (SkyblockerConfigManager.get().uiAndVisuals.smoothAOTE.enableInstantTransmission) {
					distance = extractTunedCustomData(customData, 8);
					break;
				}
				return;
			}
			case "ETHERWARP_CONDUIT" -> {
				if (SkyblockerConfigManager.get().uiAndVisuals.smoothAOTE.enableEtherTransmission) {
					distance = extractTunedCustomData(customData, 57);
					break;
				}
				return;
			}
			case "SINSEEKER_SCYTHE" -> {
				if (SkyblockerConfigManager.get().uiAndVisuals.smoothAOTE.enableSinrecallTransmission) {
					distance = extractTunedCustomData(customData, 4);
					break;
				}
				return;
			}
			case "NECRON_BLADE", "ASTRAEA", "HYPERION", "SCYLLA", "VALKYRIE" -> {
				if (SkyblockerConfigManager.get().uiAndVisuals.smoothAOTE.enableWitherImpact) {
					distance = 10;
					break;
				}
				return;
			}
			default -> {
				return;
			}
		}
		//make sure the player has enough mana to do the teleport
		Matcher manaNeeded = ItemUtils.getLoreLineIfMatch(heldItem, MANA_LORE);
		if (manaNeeded != null && manaNeeded.matches()) {
			int manaCost = Integer.parseInt(manaNeeded