path: root/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/ItemCooldowns.java

/*
 * Copyright (C) 2022-2024 NotEnoughUpdates contributors
 *
 * This file is part of NotEnoughUpdates.
 *
 * NotEnoughUpdates is free software: you can redistribute it
 * and/or modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation, either
 * version 3 of the License, or (at your option) any later version.
 *
 * NotEnoughUpdates is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
 */

package io.github.moulberry.notenoughupdates.miscfeatures;

import io.github.moulberry.notenoughupdates.NotEnoughUpdates;
import io.github.moulberry.notenoughupdates.autosubscribe.NEUAutoSubscribe;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.Minecraft;
import net.minecraft.init.Blocks;
import net.minecraft.item.ItemStack;
import net.minecraft.network.play.server.S23PacketBlockChange;
import net.minecraft.util.BlockPos;
import net.minecraftforge.client.event.ClientChatReceivedEvent;
import net.minecraftforge.event.entity.player.PlayerInteractEvent;
import net.minecraftforge.event.world.WorldEvent;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.common.gameevent.TickEvent;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@NEUAutoSubscribe
public class ItemCooldowns {

	private static final Pattern COOLDOWN_LORE = Pattern.compile("\\u00a78Cooldown: \\u00a7a(\\d+)s");

	private static final Pattern PICKAXE_ABILITY_ACTIVATION =
		Pattern.compile("\\u00a7r\\u00a7aYou used your \\u00a7r\\u00a7..+ \\u00a7r\\u00a7aPickaxe Ability!\\u00a7r");

	private static final Pattern BONZO_ABILITY_ACTIVATION =
		Pattern.compile(
			"\\u00a7r\\u00a7aYour \\u00a7r\\u00a7[9|5](\\u269A )*Bonzo's Mask \\u00a7r\\u00a7asaved your life!\\u00a7r");

	private static final Pattern SPIRIT_ABILITY_ACTIVATION =
		Pattern.compile(
			"\\u00a7r\\u00a76Second Wind Activated\\u00a7r\\u00a7a! \\u00a7r\\u00a7aYour Spirit Mask saved your life!\\u00a7r");

	private static final Pattern SPRAYONATOR_ACTIVATION =
		Pattern.compile("§r§a§lSPRAYONATOR! §r§7You sprayed §r§aPlot §r§7- §r§b.* §r§7with §r§a.*§r§7!§r");

	private static final Map<ItemStack, Float> durabilityOverrideMap = new HashMap<>();

	public static long pickaxeUseCooldownMillisRemaining = -1;
	private static long treecapitatorCooldownMillisRemaining = -1;
	private static long bonzomaskCooldownMillisRemaining = -1;
	private static long spiritMaskCooldownMillisRemaining = -1;
	private static long sprayonatorCooldownMillisRemaining = -1;
	private static long grappleCooldownMillisRemaining = -1;

	public static boolean firstLoad = true;
	public static long firstLoadMillis = 0;

	private static long lastMillis = 0;

	public static long pickaxeCooldown = -1;
	private static long bonzoMaskCooldown = -1;
	private static long spiritMaskCooldown = -1;
	private static long sprayonatorCooldown = -1;

	private static long grappleCooldown = 2000;
	private static HashSet<String> grappleSetIds = new HashSet<String>() {{
		add("BAT_PERSON_BOOTS");
		add("BAT_PERSON_LEGGINGS");
		add("BAT_PERSON_CHESTPLATE");
		add("BAT_PERSON_HELMET");
	}};

	public static TreeMap<Long, BlockData> blocksClicked = new TreeMap<>();

	private static int tickCounter = 0;

	/**
	 * Class to store the block state at a position, the moment the position is passed
	 */
	public static class BlockData {

		public BlockPos blockPos;
		public IBlockState blockState;

		public BlockData(BlockPos pos) {
			this.blockPos = pos;
			this.blockState = Minecraft.getMinecraft().theWorld.getBlockState(pos);
		}
	}

	enum Item {
		PICKAXES,
		BONZO_MASK,
		SPIRIT_MASK,
		SPRAYONATOR
	}

	@SubscribeEvent
	public void tick(TickEvent.ClientTickEvent event) {
		if (event.phase == TickEvent.Phase.END && NotEnoughUpdates.INSTANCE.hasSkyblockScoreboard()) {
			if (tickCounter++ >= 20 * 10) {
				tickCounter = 0;
				pickaxeCooldown = -1;
				bonzoMaskCooldown = -1;
				spiritMaskCooldown = -1;
				sprayonatorCooldown = -1;
			}

			long currentTime = System.currentTimeMillis();
			if (firstLoad) {
				firstLoadMillis = currentTime;
				firstLoad = false;
			}

			Long key;
			while ((key = blocksClicked.floorKey(currentTime - 1500)) != null) {
				blocksClicked.remove(key);
			}

			long millisDelta = currentTime - lastMillis;
			lastMillis = currentTime;

			durabilityOverrideMap.clear();

			if (pickaxeUseCooldownMillisRemaining >= 0) {
				pickaxeUseCooldownMillisRemaining -= millisDelta;
			}
			if (treecapitatorCooldownMillisRemaining >= 0) {
				treecapitatorCooldownMillisRemaining -= millisDelta;
			}
			if (bonzomaskCooldownMillisRemaining >= 0) {
				bonzomaskCooldownMillisRemaining -= millisDelta;
			}
			if (spiritMaskCooldownMillisRemaining >= 0) {
				spiritMaskCooldownMillisRemaining -= millisDelta;
			}
			if (sprayonatorCooldownMillisRemaining >= 0) {
				sprayonatorCooldownMillisRemaining -= millisDelta;
			}
			if (grappleCooldownMillisRemaining >= 0) {
				grappleCooldownMillisRemaining -= millisDelta;
			}
		}
	}

	@SubscribeEvent
	public void onWorldLoad(WorldEvent.Load event) {
		blocksClicked.clear();
		if (pickaxeCooldown > 0) pickaxeUseCooldownMillisRemaining = 60 * 1000;
		pickaxeCooldown = -1;
	}

	@SubscribeEvent
	public void onPlayerInteract(PlayerInteractEvent event) {
		if (event.action == PlayerInteractEvent.Action.RIGHT_CLICK_AIR ||
			event.action == PlayerInteractEvent.Action.RIGHT_CLICK_BLOCK) {
			ItemStack held = Minecraft.getMinecraft().thePlayer.getHeldItem();
			String internalname =
				NotEnoughUpdates.INSTANCE.manager.createItemResolutionQuery().withItemStack(held).resolveInternalName();
			if (internalname != null) {
				if (grappleCooldownMillisRemaining < 0 && internalname.equals("GRAPPLING_HOOK") &&
					Minecraft.getMinecraft().thePlayer.fishEntity != null) {
					grappleCooldownMillisRemaining = getGrappleCooldownWithArmor();
				}
			}
		}
	}

	public static long getTreecapCooldownWithPet() {
		if (!NotEnoughUpdates.INSTANCE.config.itemOverlays.enableCooldownInItemDurability) {
			return 0;
		}

		PetInfoOverlay.Pet pet = PetInfoOverlay.getCurrentPet();
		if (NotEnoughUpdates.INSTANCE.config.itemOverlays.enableMonkeyCheck && pet != null) {
			if (pet.petLevel != null &&
				pet.petType.equalsIgnoreCase("monkey") &&
				pet.rarity.equals(PetInfoOverlay.Rarity.LEGENDARY)
			) {
				return 2000 - (int) (2000 * (0.005 * pet.petLevel.getCurrentLevel()));
			}
		}
		return 2000;
	}

	public static long getGrappleCooldownWithArmor() {
		if (!NotEnoughUpdates.INSTANCE.config.itemOverlays.enableGrappleOverlay) {
			return 0;
		}

		for (int i = 0; i < 4; i++) {
			ItemStack armorPiece = Minecraft.getMinecraft().thePlayer.getCurrentArmor(i);
			String internal =
				NotEnoughUpdates.INSTANCE.manager.createItemResolutionQuery().withItemStack(armorPiece).resolveInternalName();
			if (internal != null) {
				if (!grappleSetIds.contains(internal)) return grappleCooldown;
			} else return grappleCooldown;
		}
		return 0;
	}

	public static void blockClicked(BlockPos pos) {
		long currentTime = System.currentTimeMillis();
		blocksClicked.put(currentTime, new BlockData(pos));
	}

	public static void processBlockChangePacket(S23PacketBlockChange packetIn) {
		BlockPos pos = packetIn.getBlockPosition();
		<