From d0345f39230e4f07f061b6c82a381c863e9787d8 Mon Sep 17 00:00:00 2001 From: Thunderblade73 <85900443+Thunderblade73@users.noreply.github.com> Date: Tue, 7 May 2024 22:43:17 +0200 Subject: Feature: Tunnels maps (#1546) Co-authored-by: hannibal2 <24389977+hannibal00212@users.noreply.github.com> --- src/main/java/at/hannibal2/skyhanni/SkyHanniMod.kt | 2 + .../at/hannibal2/skyhanni/config/ConfigManager.kt | 11 + .../config/features/mining/MiningConfig.java | 3 + .../config/features/mining/TunnelMapsConfig.java | 80 ++++ .../hannibal2/skyhanni/data/EntityMovementData.kt | 23 ++ .../java/at/hannibal2/skyhanni/data/model/Graph.kt | 180 ++++++++ .../hannibal2/skyhanni/events/LorenzWarpEvent.kt | 3 + .../skyhanni/events/RepositoryReloadEvent.kt | 2 +- .../skyhanni/features/mining/TunnelsMaps.kt | 451 +++++++++++++++++++++ .../skyhanni/test/SkyHanniDebugsAndTests.kt | 16 +- .../at/hannibal2/skyhanni/utils/CollectionUtils.kt | 24 ++ .../java/at/hannibal2/skyhanni/utils/ColorUtils.kt | 2 + .../at/hannibal2/skyhanni/utils/LorenzColor.kt | 8 + .../java/at/hannibal2/skyhanni/utils/LorenzVec.kt | 1 + .../at/hannibal2/skyhanni/utils/RenderUtils.kt | 204 ++++++++-- 15 files changed, 970 insertions(+), 40 deletions(-) create mode 100644 src/main/java/at/hannibal2/skyhanni/config/features/mining/TunnelMapsConfig.java create mode 100644 src/main/java/at/hannibal2/skyhanni/data/model/Graph.kt create mode 100644 src/main/java/at/hannibal2/skyhanni/events/LorenzWarpEvent.kt create mode 100644 src/main/java/at/hannibal2/skyhanni/features/mining/TunnelsMaps.kt (limited to 'src/main/java') diff --git a/src/main/java/at/hannibal2/skyhanni/SkyHanniMod.kt b/src/main/java/at/hannibal2/skyhanni/SkyHanniMod.kt index b615238db..5caf50566 100644 --- a/src/main/java/at/hannibal2/skyhanni/SkyHanniMod.kt +++ b/src/main/java/at/hannibal2/skyhanni/SkyHanniMod.kt @@ -298,6 +298,7 @@ import at.hannibal2.skyhanni.features.mining.HighlightMiningCommissionMobs import at.hannibal2.skyhanni.features.mining.KingTalismanHelper import at.hannibal2.skyhanni.features.mining.MiningCommissionsBlocksColor import at.hannibal2.skyhanni.features.mining.MiningNotifications +import at.hannibal2.skyhanni.features.mining.TunnelsMaps import at.hannibal2.skyhanni.features.mining.crystalhollows.CrystalHollowsNamesInCore import at.hannibal2.skyhanni.features.mining.crystalhollows.CrystalHollowsWalls import at.hannibal2.skyhanni.features.mining.eventtracker.MiningEventDisplay @@ -610,6 +611,7 @@ class SkyHanniMod { loadModule(DungeonMilestonesDisplay) loadModule(DungeonDeathCounter()) loadModule(DungeonCleanEnd()) + loadModule(TunnelsMaps()) loadModule(DungeonBossMessages()) loadModule(DungeonBossHideDamageSplash()) loadModule(UniqueGiftingOpportunitiesFeatures) diff --git a/src/main/java/at/hannibal2/skyhanni/config/ConfigManager.kt b/src/main/java/at/hannibal2/skyhanni/config/ConfigManager.kt index c3b011d0e..5c85c97ec 100644 --- a/src/main/java/at/hannibal2/skyhanni/config/ConfigManager.kt +++ b/src/main/java/at/hannibal2/skyhanni/config/ConfigManager.kt @@ -159,6 +159,17 @@ class ConfigManager { .create() var configDirectory = File("config/skyhanni") + + inline fun GsonBuilder.registerTypeAdapter( + crossinline write: (JsonWriter, T) -> Unit, + crossinline read: (JsonReader) -> T, + ): GsonBuilder { + this.registerTypeAdapter(T::class.java, object : TypeAdapter() { + override fun write(out: JsonWriter, value: T) = write(out, value) + override fun read(reader: JsonReader) = read(reader) + }.nullSafe()) + return this + } } val features get() = jsonHolder[ConfigFileType.FEATURES] as Features diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/mining/MiningConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/mining/MiningConfig.java index b529a7c91..6d8bd06ab 100644 --- a/src/main/java/at/hannibal2/skyhanni/config/features/mining/MiningConfig.java +++ b/src/main/java/at/hannibal2/skyhanni/config/features/mining/MiningConfig.java @@ -47,6 +47,9 @@ public class MiningConfig { @Accordion public MiningNotificationsConfig notifications = new MiningNotificationsConfig(); + @Expose + @Category(name = "Tunnel Maps", desc = "Settings for the Tunnel Maps") + public TunnelMapsConfig tunnelMaps = new TunnelMapsConfig(); @Expose @ConfigOption(name = "Commissions Blocks Color", desc = "") @Accordion diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/mining/TunnelMapsConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/mining/TunnelMapsConfig.java new file mode 100644 index 000000000..99f36a429 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/config/features/mining/TunnelMapsConfig.java @@ -0,0 +1,80 @@ +package at.hannibal2.skyhanni.config.features.mining; + +import at.hannibal2.skyhanni.config.FeatureToggle; +import at.hannibal2.skyhanni.config.core.config.Position; +import com.google.gson.annotations.Expose; +import io.github.notenoughupdates.moulconfig.annotations.ConfigEditorBoolean; +import io.github.notenoughupdates.moulconfig.annotations.ConfigEditorColour; +import io.github.notenoughupdates.moulconfig.annotations.ConfigEditorKeybind; +import io.github.notenoughupdates.moulconfig.annotations.ConfigEditorSlider; +import io.github.notenoughupdates.moulconfig.annotations.ConfigLink; +import io.github.notenoughupdates.moulconfig.annotations.ConfigOption; +import io.github.notenoughupdates.moulconfig.observer.Property; +import org.lwjgl.input.Keyboard; + +public class TunnelMapsConfig { + + @Expose + @ConfigOption(name = "Enable", desc = "Enables the tunnel maps, which give you a path to any location you want. Open the Inventory to select a destination.") + @ConfigEditorBoolean + @FeatureToggle + public boolean enable = true; + + @ConfigLink(owner = TunnelMapsConfig.class, field = "enable") + public Position position = new Position(20, 20); + + @Expose + @ConfigOption(name = "Auto Commission", desc = "Takes the first collector commission as target when opening the commissions inventory, also works when completing commissions.") + @ConfigEditorBoolean + public boolean autoCommission = false; + + @Expose + @ConfigOption(name = "Campfire Hotkey", desc = "Hotkey to warp to the campfire, if the travel scroll is not unlocked shows a path to the campfire.") + @ConfigEditorKeybind(defaultKey = Keyboard.KEY_NONE) + public int campfireKey = Keyboard.KEY_NONE; + + @Expose + @ConfigOption(name = "Travel Scroll", desc = "Lets the mod know that you have unlocked the travel scroll to basecamp.") + @ConfigEditorBoolean + public boolean travelScroll = false; + + @Expose + @ConfigOption(name = "Next Spot Hotkey", desc = "Hotkey to select the next spot.") + @ConfigEditorKeybind(defaultKey = Keyboard.KEY_NONE) + public int nextSpotHotkey = Keyboard.KEY_NONE; + + @Expose + @ConfigOption(name = "Dynamic Path Colour", desc = "Instead of the selected color use the color of the target as line colour.") + @ConfigEditorBoolean + public boolean dynamicPathColour = true; + + @Expose + @ConfigOption(name = "Path Colour", desc = "The colour for the paths, if the dynamic colour option is turned off.") + @ConfigEditorColour + public String pathColour = "0:255:0:255:0"; + + @Expose + @ConfigOption(name = "Text Size", desc = "Size of the waypoint texts.") + @ConfigEditorSlider(minValue = 0.5f, maxValue = 2.5f, minStep = 0.1f) + public float textSize = 1.0f; + + @Expose + @ConfigOption(name = "Path width", desc = "Size of the path lines.") + @ConfigEditorSlider(minValue = 1f, maxValue = 15f, minStep = 1f) + public float pathWidth = 4.0f; + + @Expose + @ConfigOption(name = "Distance at First", desc = "Shows the distance at the first edge instead of the end.") + @ConfigEditorBoolean + public boolean distanceFirst = false; + + @Expose + @ConfigOption(name = "Compact Gemstone", desc = "Only shows the icon for gemstones in the selection list.") + @ConfigEditorBoolean + public Property compactGemstone = Property.of(false); + + @Expose + @ConfigOption(name = "Exclude Fairy", desc = "Excludes the fairy soul spots from the selection list.") + @ConfigEditorBoolean + public Property excludeFairy = Property.of(false); +} diff --git a/src/main/java/at/hannibal2/skyhanni/data/EntityMovementData.kt b/src/main/java/at/hannibal2/skyhanni/data/EntityMovementData.kt index ae5a03878..97039022a 100644 --- a/src/main/java/at/hannibal2/skyhanni/data/EntityMovementData.kt +++ b/src/main/java/at/hannibal2/skyhanni/data/EntityMovementData.kt @@ -1,11 +1,16 @@ package at.hannibal2.skyhanni.data import at.hannibal2.skyhanni.events.EntityMoveEvent +import at.hannibal2.skyhanni.events.LorenzChatEvent import at.hannibal2.skyhanni.events.LorenzTickEvent +import at.hannibal2.skyhanni.events.LorenzWarpEvent import at.hannibal2.skyhanni.events.LorenzWorldChangeEvent +import at.hannibal2.skyhanni.utils.DelayedRun import at.hannibal2.skyhanni.utils.LorenzUtils import at.hannibal2.skyhanni.utils.LorenzVec +import at.hannibal2.skyhanni.utils.StringUtils.matches import at.hannibal2.skyhanni.utils.getLorenzVec +import at.hannibal2.skyhanni.utils.repopatterns.RepoPattern import net.minecraft.client.Minecraft import net.minecraft.entity.Entity import net.minecraftforge.fml.common.eventhandler.SubscribeEvent @@ -41,6 +46,24 @@ class EntityMovementData { } } + private val warpingPattern by RepoPattern.pattern( + "warping", + "§7Warping...|" + + "§7Warping you to your SkyBlock island...|" + + "§7Warping using transfer token...|" + + "§7Finding player...|" + + "§7Sending a visit request..." + ) + + @SubscribeEvent + fun onChat(event: LorenzChatEvent) { + if (!LorenzUtils.inSkyBlock) return + if (!warpingPattern.matches(event.message)) return + DelayedRun.runNextTick { + LorenzWarpEvent().postAndCatch() + } + } + @SubscribeEvent fun onWorldChange(event: LorenzWorldChangeEvent) { entityLocation.clear() diff --git a/src/main/java/at/hannibal2/skyhanni/data/model/Graph.kt b/src/main/java/at/hannibal2/skyhanni/data/model/Graph.kt new file mode 100644 index 000000000..b6e6f7b8e --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/data/model/Graph.kt @@ -0,0 +1,180 @@ +package at.hannibal2.skyhanni.data.model + +import at.hannibal2.skyhanni.config.ConfigManager.Companion.registerTypeAdapter +import at.hannibal2.skyhanni.utils.LorenzVec +import at.hannibal2.skyhanni.utils.fromJson +import com.google.gson.GsonBuilder +import com.google.gson.JsonElement +import com.google.gson.annotations.Expose +import java.util.PriorityQueue + +@JvmInline +value class Graph( + @Expose + val graph: List, +) : List { + override val size + get() = graph.size + + override fun contains(element: GraphNode) = graph.contains(element) + + override fun containsAll(elements: Collection) = graph.containsAll(elements) + + override fun get(index: Int) = graph.get(index) + + override fun isEmpty() = graph.isEmpty() + + override fun indexOf(element: GraphNode) = graph.indexOf(element) + + override fun iterator(): Iterator = graph.iterator() + override fun listIterator() = graph.listIterator() + + override fun listIterator(index: Int) = graph.listIterator(index) + + override fun subList(fromIndex: Int, toIndex: Int) = graph.subList(fromIndex, toIndex) + + override fun lastIndexOf(element: GraphNode) = graph.lastIndexOf(element) + + companion object { + val gson = GsonBuilder().setPrettyPrinting() + /* ConfigManager.createBaseGsonBuilder() */.registerTypeAdapter({ out, value -> + out.beginObject() + value.forEach { + out.name(it.id.toString()).beginObject() + out.name("Position").value(with(it.position) { "$x:$y:$z" }) + if (it.name != null) { + out.name("Name").value(it.name) + } + out.name("Neighbours") + out.beginObject() + it.neighbours.forEach { (node, weight) -> + val id = node.id.toString() + out.name(id).value(weight) + } + out.endObject() + out.endObject() + } + out.endObject() + }, { reader -> + reader.beginObject() + val list = mutableListOf() + val neigbourMap = mutableMapOf>>() + while (reader.hasNext()) { + val id = reader.nextName().toInt() + reader.beginObject() + var position: LorenzVec? = null + var name: String? = null + var neighbors = mutableListOf>() + while (reader.hasNext()) { + when (reader.nextName()) { + "Position" -> { + position = reader.nextString().split(":").let { parts -> + LorenzVec(parts[0].toDouble(), parts[1].toDouble(), parts[2].toDouble()) + } + } + + "Neighbours" -> { + reader.beginObject() + while (reader.hasNext()) { + val nId = reader.nextName().toInt() + val distance = reader.nextDouble() + neighbors.add(nId to distance) + } + reader.endObject() + } + + "Name" -> { + name = reader.nextString() + } + + } + } + val node = GraphNode(id, position!!, name) + list.add(node) + neigbourMap[node] = neighbors + reader.endObject() + } + neigbourMap.forEach { (node, edge) -> + node.neighbours = edge.associate { (id, distance) -> + list.first { it.id == id } to distance + } + } + reader.endObject() + Graph(list) + }).create() + + fun fromJson(json: String): Graph = gson.fromJson(json) + fun fromJson(json: JsonElement): Graph = gson.fromJson(json) + } +} + +class GraphNode(val id: Int, val position: LorenzVec, val name: String? = null) { + + /** Keys are the neighbours and value the edge weight (e.g. Distance) */ + lateinit var neighbours: Map + + override fun hashCode(): Int { + return id + } + + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (javaClass != other?.javaClass) return false + + other as GraphNode + + if (id != other.id) return false + + return true + } +} + +fun Graph.findShortestPathAsGraph(start: GraphNode, end: GraphNode): Graph = + this.findShortestPathAsGraphWithDistance(start, end).first + +fun Graph.findShortestPathAsGraphWithDistance(start: GraphNode, end: GraphNode): Pair { + val distances = mutableMapOf() + val previous = mutableMapOf() + val visited = mutableSetOf() + val queue = PriorityQueue(compareBy { distances.getOrDefault(it, Double.MAX_VALUE) }) + + distances[start] = 0.0 + queue.add(start) + + while (queue.isNotEmpty()) { + val current = queue.poll() + if (current == end) break + + visited.add(current) + + current.neighbours.forEach { (neighbour, weight) -> + if (neighbour !in visited) { + val newDistance = distances.getValue(current) + weight + if (newDistance < distances.getOrDefault(neighbour, Double.MAX_VALUE)) { + distances[neighbour] = newDistance + previous[neighbour] = current + queue.add(neighbour) + } + } + } + } + + return Graph(buildList { + var current = end + while (current != start) { + add(current) + current = previous[current] ?: return Graph(emptyList()) to 0.0 + } + add(start) + }.reversed()) to distances[end]!! +} + +fun Graph.findShortestPath(start: GraphNode, end: GraphNode): List = + this.findShortestPathAsGraph(start, end).toPositionsList() + +fun Graph.findShortestDistance(start: GraphNode, end: GraphNode): Double = + this.findShortestPathAsGraphWithDistance(start, end).second + +fun Graph.toPositionsList() = this.map { it.position } + +fun Graph.toJson(): String = Graph.gson.toJson(this) diff --git a/src/main/java/at/hannibal2/skyhanni/events/LorenzWarpEvent.kt b/src/main/java/at/hannibal2/skyhanni/events/LorenzWarpEvent.kt new file mode 100644 index 000000000..170dcabe9 --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/events/LorenzWarpEvent.kt @@ -0,0 +1,3 @@ +package at.hannibal2.skyhanni.events + +class LorenzWarpEvent : LorenzEvent() diff --git a/src/main/java/at/hannibal2/skyhanni/events/RepositoryReloadEvent.kt b/src/main/java/at/hannibal2/skyhanni/events/RepositoryReloadEvent.kt index 3b2b426fe..fc006b049 100644 --- a/src/main/java/at/hannibal2/skyhanni/events/RepositoryReloadEvent.kt +++ b/src/main/java/at/hannibal2/skyhanni/events/RepositoryReloadEvent.kt @@ -9,7 +9,7 @@ import java.lang.reflect.Type class RepositoryReloadEvent(val repoLocation: File, val gson: Gson) : LorenzEvent() { - inline fun getConstant(constant: String, type: Type? = null): T = try { + inline fun getConstant(constant: String, type: Type? = null, gson: Gson = this.gson): T = try { RepoManager.setlastConstant(constant) if (!repoLocation.exists()) throw RepoError("Repo folder does not exist!") RepoUtils.getConstant(repoLocation, constant, gson, T::class.java, type) diff --git a/src/main/java/at/hannibal2/skyhanni/features/mining/TunnelsMaps.kt b/src/main/java/at/hannibal2/skyhanni/features/mining/TunnelsMaps.kt new file mode 100644 index 000000000..32e5864af --- /dev/null +++ b/src/main/java/at/hannibal2/skyhanni/features/mining/TunnelsMaps.kt @@ -0,0 +1,451 @@ +package at.hannibal2.skyhanni.features.mining + +import at.hannibal2.skyhanni.SkyHanniMod +import at.hannibal2.skyhanni.data.IslandType +import at.hannibal2.skyhanni.data.model.Graph +import at.hannibal2.skyhanni.data.model.GraphNode +import at.hannibal2.skyhanni.data.model.findShortestDistance +import at.hannibal2.skyhanni.data.model.findShortestPathAsGraphWithDistance +import at.hannibal2.skyhanni.events.ConfigLoadEvent +import at.hannibal2.skyhanni.events.GuiContainerEvent +import at.hannibal2.skyhanni.events.GuiRenderEvent +import at.hannibal2.skyhanni.events.InventoryFullyOpenedEvent +import at.hannibal2.skyhanni.events.LorenzKeyPressEvent +import at.hannibal2.skyhanni.events.LorenzRenderWorldEvent +import at.hannibal2.skyhanni.events.LorenzTickEvent +import at.hannibal2.skyhanni.events.LorenzToolTipEvent +import at.hannibal2.skyhanni.events.LorenzWarpEvent +import at.hannibal2.skyhanni.events.RepositoryReloadEvent +import at.hannibal2.skyhanni.test.command.ErrorManager +import at.hannibal2.skyhanni.utils.ChatUtils +import at.hannibal2.skyhanni.utils.CollectionUtils.filterNotNullKeys +import at.hannibal2.skyhanni.utils.ColorUtils.getFirstColorCode +import at.hannibal2.skyhanni.utils.ColorUtils.toChromaColor +import at.hannibal2.skyhanni.utils.ConditionalUtils.onToggle +import at.hannibal2.skyhanni.utils.DelayedRun +import at.hannibal2.skyhanni.utils.ItemUtils.getLore +import at.hannibal2.skyhanni.utils.ItemUtils.itemName +import at.hannibal2.skyhanni.utils.LocationUtils +import at.hannibal2.skyhanni.utils.LocationUtils.distanceSqToPlayer +import at.hannibal2.skyhanni.utils.LorenzColor +import at.hannibal2.skyhanni.utils.LorenzColor.Companion.toLorenzColor +import at.hannibal2.skyhanni.utils.LorenzUtils +import at.hannibal2.skyhanni.utils.LorenzUtils.isInIsland +import at.hannibal2.skyhanni.utils.NEUInternalName.Companion.asInternalName +import at.hannibal2.skyhanni.utils.RenderUtils +import at.hannibal2.skyhanni.utils.RenderUtils.draw3DPathWithWaypoint +import at.hannibal2.skyhanni.utils.RenderUtils.drawDynamicText +import at.hannibal2.skyhanni.utils.RenderUtils.renderRenderables +import at.hannibal2.skyhanni.utils.SimpleTimeMark +import at.hannibal2.skyhanni.utils.SimpleTimeMark.Companion.fromNow +import at.hannibal2.skyhanni.utils.StringUtils.anyMatches +import at.hannibal2.skyhanni.utils.StringUtils.matchFirst +import at.hannibal2.skyhanni.utils.StringUtils.matches +import at.hannibal2.skyhanni.utils.StringUtils.removeColor +import at.hannibal2.skyhanni.utils.renderables.Renderable +import at.hannibal2.skyhanni.utils.repopatterns.RepoPattern +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent +import java.awt.Color +import kotlin.math.roundToInt +import kotlin.time.Duration.Companion.seconds + +class TunnelsMaps { + + private val config get() = SkyHanniMod.feature.mining.tunnelMaps + + private var graph: Graph = Graph(emptyList()) + private lateinit var campfire: GraphNode + + private var goalReached = false + private var prevGoal: GraphNode? = null + private var goal: GraphNode? = null + set(value) { + prevGoal = field + field = value + } + + private var closedNote: GraphNode? = null + private var path: Pair? = null + + private var possibleLocations = mapOf>() + private val cooldowns = mutableMapOf() + private var active: String = "" + + private lateinit var fairySouls: Map + private lateinit var newGemstones: Map> + private lateinit var oldGemstones: Map> + private lateinit var normalLocations: Map> + + private var locationDisplay: List = emptyList() + + private fun getNext(name: String = active): GraphNode? { + fairySouls[name]?.let { + goalReached = false + return it + } + + val closed = closedNote ?: return null + val list = possibleLocations[name] ?: return null + + val offCooldown = list.filter { cooldowns[it]?.isInPast() != false } + val best = offCooldown.minByOrNull { graph.findShortestDistance(closed, it) } ?: list.minBy { + cooldowns[it] ?: SimpleTimeMark.farPast() + } + if (cooldowns[best]?.isInPast() != false) { + cooldowns[best] = 5.0.seconds.fromNow() + } + goalReached = false + return best + } + + private fun hasNext(name: String = active): Boolean { + val list = possibleLocations[name] ?: return false + return list.size > 1 + } + + private val oldGemstonePattern by RepoPattern.pattern( + "mining.tunnels.maps.gem.old", ".*(?:Ruby|Amethyst|Jade|Sapphire|Amber|Topaz).*" + ) + private val newGemstonePattern by RepoPattern.pattern( + "mining.tunnels.maps.gem.new", ".*(?:Aquamarine|Onyx|Citrine|Peridot).*" + ) + private val commissionInvPattern by RepoPattern.pattern( + "mining.commission.inventory", "Commissions" + ) + private val glacitePattern by RepoPattern.pattern( + "mining.commisson.reward.glacite", + "§7- §b\\d+ Glacite Powder" + ) + private val collectorCommissionPattern by RepoPattern.pattern( + "mining.commisson.collector", + "§9(?\\w+(?: \\w+)?) Collector" + ) + private val invalidGoalPattern by RepoPattern.pattern( + "mining.commisson.collector.invalid", + "Glacite|Scrap" + ) + private val completedPattern by RepoPattern.pattern( + "mining.commisson.completed", + "§a§lCOMPLETED" + ) + + private val translateTable = mutableMapOf() + + /** @return Errors with an empty String */ + private fun getGenericName(input: String): String = translateTable.getOrPut(input) { + possibleLocations.keys.firstOrNull() { it.uppercase().removeColor().contains(input.uppercase()) } ?: "" + } + + private var clickTranslate = mapOf() + + @SubscribeEvent + fun onInventoryFullyOpened(event: InventoryFullyOpenedEvent) { + if (!isEnabled()) return + clickTranslate = mapOf() + if (!commissionInvPattern.matches(event.inventoryName)) return + clickTranslate = event.inventoryItems.mapNotNull { (slotId, item) -> + val lore = item.getLore() + if (!glacitePattern.anyMatches(lore)) return@mapNotNull null + if (completedPattern.anyMatches(lore)) return@mapNotNull null + val type = lore.matchFirst(collectorCommissionPattern) { + group("what") + } ?: return@mapNotNull null + if (invalidGoalPattern.matches(type)) return@mapNotNull null + val mapName = getGenericName(type) + if (mapName.isEmpty()) { + ErrorManager.logErrorStateWithData( + "Unknown Collection Commission: $type", "$type can't be found in the graph.", + "type" to type, + "graphNames" to possibleLocations.keys, + "lore" to lore + ) + null + } else { + slotId to getGenericName(type) + } + }.toMap() + if (config.autoCommission) { + clickTranslate.values.firstOrNull()?.let { + setActiveAndGoal(it) + } + } + } + + @SubscribeEvent + fun onRenderItemTooltip(event: LorenzToolTipEvent) { + if (!isEnabled()) return + clickTranslate[event.slot.slotIndex]?.let { + event.toolTip.add("§e§lRight Click §r§eto for Tunnel Maps.") + } + } + + @SubscribeEvent + fun onGuiContainerSlotClick(event: GuiContainerEvent.SlotClickEvent) { + if (!isEnabled()) return + if (event.clickedButton != 1) return + clickTranslate[event.slotId]?.let { + setActiveAndGoal(it) + } + } + + @SubscribeEvent + fun onRepoReload(event: RepositoryReloadEvent) { + graph = event.getConstant("TunnelsGraph", gson = Graph.gson) + possibleLocations = graph.groupBy { it.name }.filterNotNullKeys().mapValues { (_, value) -> + value + } + val fairy = mutableMapOf() + val oldGemstone = mutableMapOf>() + val newGemstone = mutableMapOf>() + val other = mutableMapOf>() + possibleLocations.forEach { (key, value) -> + when { + key.contains("Campfire") -> campfire = value.first() + key.contains("Fairy") -> fairy[key] = value.first() + newGemstonePattern.matches(key) -> newGemstone[key] = value + oldGemstonePattern.matches(key) -> oldGemstone[key] = value + else -> other[key] = value + } + } + fairySouls = fairy + this.newGemstones = newGemstone + this.oldGemstones = oldGemstone + normalLocations = other + translateTable.clear() + DelayedRun.runNextTick { // Needs to be delayed since the config may not be loaded + locationDisplay = generateLocationsDisplay() + } + } + + @SubscribeEvent + fun onConfigLoad(event: ConfigLoadEvent) { + onToggle( + config.compactGemstone, + config.excludeFairy + ) { + locationDisplay = generateLocationsDisplay() + } + } + + @SubscribeEvent + fun onRenderDisplay(event: GuiRenderEvent.ChestGuiOverlayRenderEvent) { + if (!isEnabled()) return + val display = buildList { + if (active.isNotEmpty()) { + if (goal == campfire && active != campfire.name) { + add(Renderable.string("§6Override for ${campfire.name}")) + add(Renderable.clickable(Renderable.string("§eMake §f$active §eactive"), onClick = { + goal = getNext() + })) + } else { + add( + Renderable.clickAndHover( + Renderable.string("§6Active: §f$active"), + listOf("§eClick to disable current Waypoint"), + onClick = ::clearPath + ) + ) + if (hasNext()) { + add(Renderable.clickable(Renderable.string("§eNext Spot"), onClick = { + goal = getNext() + })) + } else { + add(Renderable.string("")) + } + } + } else { + add(Renderable.string("")) + add(Renderable.string("")) + } + addAll(locationDisplay) + } + config.position.renderRenderables(display, posLabel = "TunnelsMaps") + } + + private fun generateLocationsDisplay() = buildList { + add(Renderable.string("§6Loactions:")) + add( + Renderable.multiClickAndHover( + campfire.name!!, listOf( + "§eLeft Click to set active", "§eRight Click for override" + ), click = mapOf( + 0 to guiSetActive(campfire.name!!), 1 to ::campfireOverride + ) + ) + ) + if (!config.excludeFairy.get()) { + add(Renderable.hoverable(Renderable.horizontalContainer(listOf(Renderable.string("§dFairy Souls")) + fairySouls.map { + val name = it.key.removePrefix("§dFairy Soul ") + Renderable.clickable(Renderable.string("§d[${name}]"), onClick = guiSetActive(it.key)) + }), Renderable.string("§dFairy Souls"))) + } + if (config.compactGemstone.get()) { + add( + Renderable.table( + listOf( + newGemstones.map(::toCompactGemstoneName), oldGemstones.map(::toCompactGemstoneName) + ) + ) + ) + } else { + addAll(newGemstones.map { + Renderable.clickable(Renderable.string(it.key), onClick = guiSetActive(it.key)) + }) + addAll(oldGemstones.map { + Renderable.clickable(Renderable.string(it.key), onClick = guiSetActive(it.key)) + }) + } + addAll(normalLocations.map { + Renderable.clickable(Renderable.string(it.key), onClick = guiSetActive(it.key)) + }) + } + + private fun toCompactGemstoneName(it: Map.Entry>): Renderable = Renderable.clickAndHover( + Renderable.string((it.key.getFirstColorCode()?.let { "§$it" } ?: "") + ("ROUGH_".plus( + it.key.removeColor().removeSuffix("stone") + ).asInternalName().itemName.takeWhile { it != ' ' }.removeColor()), + horizontalAlign = RenderUtils.HorizontalAlignment.CENTER + ), + tips = listOf(it.key), + onClick = guiSetActive(it.key), + ) + + private fun campfireOverride() { + goalReached = false + goal = campfire + } + + private fun setActiveAndGoal(it: String) { + active = it + goal = getNext() + } + + private fun guiSetActive(it: String): () -> Unit = { + setActiveAndGoal(it) + } + + @SubscribeEvent + fun onTick(event: LorenzTickEvent) { + if (!isEnabled()) return + if (checkGoalReached()) return + val prevClosed = closedNote + closedNote = graph.minBy { it.position.distanceSqToPlayer() } + val closest = closedNote ?: return + val goal = goal ?: return + if (closest == prevClosed && goal == prevGoal) return + val (path, distance) = graph.findShortestPathAsGraphWithDistance(closest, goal) + val first = path.firstOrNull() + val second = path.getOrNull(1) + + val playerPosition = LocationUtils.playerLocation() + val nodeDistance = first?.let { playerPosition.distance(it.position) } ?: 0.0 + if (first != null && second != null) { + val direct = playerPosition.distance(second.position) + val firstPath = first.neighbours[second] ?: 0.0 + val around = nodeDistance + firstPath + if (direct < around) { + this.path = Graph(path.drop(1)) to (distance - firstPath + direct) + return + } + } + this.path = path to (distance + nodeDistance) + } + + private fun checkGoalReached(): Boolean { + if (goalReached) return true + val goal = goal ?: return false + val distance = goal.position.distanceSqToPlayer() + goalReached = distance < if (goal == campfire) { + 15.0 * 15.0 + } else { + 6.0 * 6.0 + } + if (goalReached) { + if (goal == campfire && active != campfire.name) { + this.goal = getNext() + } else { + cooldowns[goal] = 60.0.seconds.fromNow() + clearPath() + } + return true + } + return false + } + + private fun clearPath() { + path = null + goal = null + } + + @SubscribeEvent + fun onRenderWorld(event: LorenzRenderWorldEvent) { + if (!isEnabled()) return + val path = path?.takeIf { it.first.isNotEmpty() } ?: return + event.draw3DPathWithWaypoint( + path.first, + getPathColor(), + config.pathWidth.toInt(), + true, + bezierPoint = 2.0, + textSize = config.textSize.toDouble() + ) + event.drawDynamicText( + if (config.distanceFirst) { + path.first.first() + } else { + path.first.last() + }.position, + "§e${path.second.roundToInt()}m", + config.textSize.toDouble(), + yOff = 10f + ) + } + + private fun getPathColor(): Color = if (config.dynamicPathColour) { + goal?.name?.getFirstColorCode()?.toLorenzColor()?.takeIf { it != LorenzColor.WHITE }?.toColor() + } else { + null + } ?: config.pathColour.toChromaColor() + + @SubscribeEvent + fun onKeyPress(event: LorenzKeyPressEvent) { + if (!isEnabled()) return + campfireKey(event) + nextSpotKey(event) + } + + private fun campfireKey(event: LorenzKeyPressEvent) { + if (event.keyCode != config.campfireKey) return + if (config.travelScroll) { + ChatUtils.sendMessageToServer("/warp basecamp") + } else { + campfireOverride() + } + } + + @SubscribeEvent + fun onLorenzWarp(event: LorenzWarpEvent) { + if (!isEnabled()) return + if (goal != null) { + DelayedRun.runNextTick { + goal = getNext() + } + } + } + + private var nextSpotDelay = SimpleTimeMark.farPast() + + private fun nextSpotKey(event: LorenzKeyPressEvent) { + if (event.keyCode != config.nextSpotHotkey) return + if (!nextSpotDelay.isInPast()) return + nextSpotDelay = 0.5.seconds.fromNow() + goal = getNext() + } + + val areas = setOf( + "Glacite Tunnels", "Dwarven Base Camp", "Glacite Lake", "Fossil Research Center" + ) + + private fun isEnabled() = + IslandType.DWARVEN_MINES.isInIsland() && config.enable && areas.contains(LorenzUtils.skyBlockArea) +} diff --git a/src/main/java/at/hannibal2/skyhanni/test/SkyHanniDebugsAndTests.kt b/src/main/java/at/hannibal2/skyhanni/test/SkyHanniDebugsAndTests.kt index b81a25599..0ae712f9d 100644 --- a/src/main/java/at/hannibal2/skyhanni/test/SkyHanniDebugsAndTests.kt +++ b/src/main/java/at/hannibal2/skyhanni/test/SkyHanniDebugsAndTests.kt @@ -7,6 +7,7 @@ import at.hannibal2.skyhanni.config.ConfigManager import at.hannibal2.skyhanni.config.ConfigUpdaterMigrator import at.hannibal2.skyhanni.config.core.config.Position import at.hannibal2.skyhanni.data.HypixelData +import at.hannibal2.skyhanni.data.model.Graph import at.hannibal2.skyhanni.events.GuiKeyPressEvent import at.hannibal2.skyhanni.events.GuiRenderEvent import at.hannibal2.skyhanni.events.LorenzChatEvent @@ -43,6 +44,7 @@ import at.hannibal2.skyhanni.utils.NEUItems.getPriceOrNull import at.hannibal2.skyhanni.utils.NumberUtil.addSeparators import at.hannibal2.skyhanni.utils.OSUtils import at.hannibal2.skyhanni.utils.ReflectionUtils.makeAccessible +import at.hannibal2.skyhanni.utils.RenderUtils.draw3DPathWithWaypoint import at.hannibal2.skyhanni.utils.RenderUtils.drawDynamicText import at.hannibal2.skyhanni.utils.RenderUtils.renderRenderables import at.hannibal2.skyhanni.utils.RenderUtils.renderString @@ -52,6 +54,7 @@ import at.hannibal2.skyhanni.utils.SoundUtils import at.hannibal2.skyhanni.utils.renderables.Renderable import at.hannibal2.skyhanni.utils.renderables.Renderable.Companion.renderBounds import kotlinx.coroutines.launch +import kotlinx.coroutines.runBlocking import net.minecraft.client.Minecraft import net.minecraft.init.Blocks import net.minecraft.init.Items @@ -59,6 +62,7 @@ import net.minecraft.item.ItemStack import net.minecraft.nbt.NBTTagCompound import net.minecraftforge.common.MinecraftForge import net.minecraftforge.fml.common.eventhandler.SubscribeEvent +import java.awt.Color import java.io.File import kotlin.time.Duration.Companion.seconds @@ -116,9 +120,14 @@ class SkyHanniDebugsAndTests { ChatUtils.chat("set test waypoint") } + var path: Graph = Graph(emptyList()) + fun testCommand(args: Array) { SoundUtils.playBeepSound() - + runBlocking { + val input = OSUtils.readFromClipboard() ?: return@runBlocking + path = Graph.fromJson(input) + } // val a = Thread { OSUtils.copyToClipboard("123") } // val b = Thread { OSUtils.copyToClipboard("456") } // a.start() @@ -424,6 +433,11 @@ class SkyHanniDebugsAndTests { ChatUtils.chat("§eCopied internal name §7$rawInternalName §eto the clipboard!") } + @SubscribeEvent + fun onTestGraphPath(event: LorenzRenderWorldEvent) { + event.draw3DPathWithWaypoint(path, Color.GREEN, 8, true) + } + @SubscribeEvent fun onShowInternalName(event: LorenzToolTipEvent) { if (!LorenzUtils.inSkyBlock) return diff --git a/src/main/java/at/hannibal2/skyhanni/utils/CollectionUtils.kt b/src/main/java/at/hannibal2/skyhanni/utils/CollectionUtils.kt index 53ae224d9..915677bb6 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/CollectionUtils.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/CollectionUtils.kt @@ -285,4 +285,28 @@ object CollectionUtils { } return destination } + + inline fun Iterable.zipWithNext3(transform: (a: T, b: T, c: T) -> R): List { + val iterator = iterator() + if (!iterator.hasNext()) return emptyList() + var one = iterator.next() + if (!iterator.hasNext()) return emptyList() + var two = iterator.next() + val result = mutableListOf() + while (iterator.hasNext()) { + val next = iterator.next() + result.add(transform(one, two, next)) + one = two + two = next + } + return result + } + + fun Iterable.zipWithNext3(): List> { + return zipWithNext3 { a, b, c -> Triple(a, b, c) } + } + + fun Map.filterNotNullKeys(): Map { + return filterKeys { it != null } as Map + } } diff --git a/src/main/java/at/hannibal2/skyhanni/utils/ColorUtils.kt b/src/main/java/at/hannibal2/skyhanni/utils/ColorUtils.kt index 97a1342c1..e5ff47073 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/ColorUtils.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/ColorUtils.kt @@ -9,6 +9,8 @@ object ColorUtils { fun String.toChromaColor() = Color(toChromaColorInt(), true) fun String.toChromaColorInt() = SpecialColour.specialToChromaRGB(this) + fun String.getFirstColorCode() = this.takeIf { it.firstOrNull() == '§' }?.getOrNull(1) + fun getRed(colour: Int) = colour shr 16 and 0xFF fun getGreen(colour: Int) = colour shr 8 and 0xFF diff --git a/src/main/java/at/hannibal2/skyhanni/utils/LorenzColor.kt b/src/main/java/at/hannibal2/skyhanni/utils/LorenzColor.kt index 16fe8cd6e..08de7038a 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/LorenzColor.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/LorenzColor.kt @@ -81,5 +81,13 @@ enum class LorenzColor(val chatColorCode: Char, private val color: Color, privat EnumDyeColor.BROWN -> GOLD EnumDyeColor.BLACK -> BLACK } + + fun Char.toLorenzColor(): LorenzColor? = entries.firstOrNull { it.chatColorCode == this } ?: run { + ErrorManager.logErrorWithData( + Exception("Unknown chat color: $this"), + "Unknown chat color: $this" + ) + null + } } } diff --git a/src/main/java/at/hannibal2/skyhanni/utils/LorenzVec.kt b/src/main/java/at/hannibal2/skyhanni/utils/LorenzVec.kt index 55be8cd3e..dc143a841 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/LorenzVec.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/LorenzVec.kt @@ -136,6 +136,7 @@ data class LorenzVec( fun clone(): LorenzVec = LorenzVec(x, y, z) fun toDoubleArray(): Array = arrayOf(x, y, z) + fun toFloatArray(): Array = arrayOf(x.toFloat(), y.toFloat(), z.toFloat()) fun equalsIgnoreY(other: LorenzVec) = x == other.x && z == other.z diff --git a/src/main/java/at/hannibal2/skyhanni/utils/RenderUtils.kt b/src/main/java/at/hannibal2/skyhanni/utils/RenderUtils.kt index d17831fb5..fb97a8357 100644 --- a/src/main/java/at/hannibal2/skyhanni/utils/RenderUtils.kt +++ b/src/main/java/at/hannibal2/skyhanni/utils/RenderUtils.kt @@ -5,13 +5,19 @@ import at.hannibal2.skyhanni.data.GuiEditManager import at.hannibal2.skyhanni.data.GuiEditManager.Companion.getAbsX import at.hannibal2.skyhanni.data.GuiEditManager.Companion.getAbsY import at.hannibal2.skyhanni.data.GuiEditManager.Companion.getDummySize +import at.hannibal2.skyhanni.data.model.Graph +import at.hannibal2.skyhanni.data.model.toPositionsList import at.hannibal2.skyhanni.events.GuiContainerEvent import at.hannibal2.skyhanni.events.GuiRenderItemEvent import at.hannibal2.skyhanni.events.LorenzRenderWorldEvent import at.hannibal2.skyhanni.events.RenderGuiItemOverlayEvent import at.hannibal2.skyhanni.features.misc.RoundedRectangleOutlineShader import at.hannibal2.skyhanni.features.misc.RoundedRectangleShader +import at.hannibal2.skyhanni.test.GriffinUtils.drawWaypointFilled import at.hannibal2.skyhanni.test.command.ErrorManager +import at.hannibal2.skyhanni.utils.CollectionUtils.zipWithNext3 +import at.hannibal2.skyhanni.utils.ColorUtils.getFirstColorCode +import at.hannibal2.skyhanni.utils.LorenzColor.Companion.toLorenzColor import at.hannibal2.skyhanni.utils.renderables.Renderable import at.hannibal2.skyhanni.utils.renderables.RenderableUtils.renderXAligned import at.hannibal2.skyhanni.utils.shader.ShaderManager @@ -35,6 +41,7 @@ import net.minecraft.util.MathHelper import net.minecraft.util.ResourceLocation import org.lwjgl.opengl.GL11 import java.awt.Color +import java.nio.FloatBuffer import kotlin.math.cos import kotlin.math.max import kotlin.math.sin @@ -66,8 +73,9 @@ object RenderUtils { private val beaconBeam = ResourceLocation("textures/entity/beacon_beam.png") - private val matrixBuffer = GLAllocation.createDirectFloatBuffer(16) - private val colourBuffer = GLAllocation.createDirectFloatBuffer(16) + private val matrixBuffer: FloatBuffer = GLAllocation.createDirectFloatBuffer(16); + private val colourBuffer: FloatBuffer = GLAllocation.createDirectFloatBuffer(16) + private val bezier2Buffer: FloatBuffer = GLAllocation.createDirectFloatBuffer(9) infix fun Slot.highlight(color: LorenzColor) { highlight(color.toColor()) @@ -1017,43 +1025,10 @@ object RenderUtils { } } - fun LorenzRenderWorldEvent.draw3DLine(p1: LorenzVec, p2: LorenzVec, color: Color, lineWidth: Int, depth: Boolean) { - GlStateManager.disableCull() - - val render = Minecraft.getMinecraft().renderViewEntity - val worldRenderer = Tessellator.getInstance().worldRenderer - val realX = render.lastTickPosX + (render.posX - render.lastTickPosX) * partialTicks - val realY = render.lastTickPosY + (render.posY - render.lastTickPosY) * partialTicks - val realZ = render.lastTickPosZ + (render.posZ - render.lastTickPosZ) * partialTicks - GlStateManager.pushMatrix() - GlStateManager.translate(-realX, -realY, -realZ) - GlStateManager.disableTexture2D() - GlStateManager.enableBlend() - GlStateManager.disableAlpha() - GlStateManager.tryBlendFuncSeparate(770, 771, 1, 0) - GL11.glLineWidth(lineWidth.toFloat()) - if (!depth) { - GL11.glDisable(GL11.GL_DEPTH_TEST) - GlStateManager.depthMask(false) - } - GlStateManager.color(color.red / 255f, color.green / 255f, color.blue / 255f, color.alpha / 255f) - worldRenderer.begin(GL11.GL_LINE_STRIP, DefaultVertexFormats.POSITION) - worldRenderer.pos(p1.x, p1.y, p1.z).endVertex() - worldRenderer.pos(p2.x, p2.y, p2.z).endVertex() - Tessellator.getInstance().draw() - GlStateManager.translate(realX, realY, realZ) - if (!depth) { - GL11.glEnable(GL11.GL_DEPTH_TEST) - GlStateManager.depthMask(true) + fun LorenzRenderWorldEvent.draw3DLine(p1: LorenzVec, p2: LorenzVec, color: Color, lineWidth: Int, depth: Boolean) = + LineDrawer.draw3D(partialTicks) { + draw3DLine(p1, p2, color, lineWidth, depth) } - GlStateManager.disableBlend() - GlStateManager.enableAlpha() - GlStateManager.enableTexture2D() - GlStateManager.color(1.0f, 1.0f, 1.0f, 1.0f) - GlStateManager.popMatrix() - GlStateManager.disableLighting() - GlStateManager.enableDepth() - } fun LorenzRenderWorldEvent.exactLocation(entity: Entity) = exactLocation(entity, partialTicks) @@ -1232,6 +1207,159 @@ object RenderUtils { ) } + fun LorenzRenderWorldEvent.draw3DPathWithWaypoint( + path: Graph, + colorLine: Color, + lineWidth: Int, + depth: Boolean, + startAtEye: Boolean = true, + textSize: Double = 1.0, + waypointColor: Color = + (path.lastOrNull()?.name?.getFirstColorCode()?.toLorenzColor() ?: LorenzColor.WHITE).toColor(), + bezierPoint: Double = 1.0, + ) { + if (path.isEmpty()) return + val points = if (startAtEye) { + listOf( + this.exactPlayerEyeLocation() + + Minecraft.getMinecraft().thePlayer.getLook(this.partialTicks) + .toLorenzVec()/* .rotateXZ(-Math.PI / 72.0) */.times(2) + ) + } else { + emptyList() + } + path.toPositionsList().map { it.add(0.5, 0.5, 0.5) } + LineDrawer.draw3D(partialTicks) { + drawPath( + points, + colorLine, + lineWidth, + depth, + bezierPoint + ) + } + path.filter { it.name?.isNotEmpty() == true }.forEach { + this.drawDynamicText(it.position, it.name!!, textSize) + } + val last = path.last() + drawWaypointFilled(last.position, waypointColor, seeThroughBlocks = true) + } + + class LineDrawer @PublishedApi internal constructor(val tessellator: Tessellator) { + val worldRenderer = tessellator.worldRenderer + fun drawPath(path: List, color: Color, lineWidth: Int, depth: Boolean, bezierPoint: Double = 1.0) { + if (bezierPoint < 0) { + path.zipWithNext().forEach { + draw3DLine(it.first, it.second, color, lineWidth, depth) + } + } else { + val pathLines = path.zipWithNext() + pathLines.forEachIndexed { index, it -> + val reduce = it.second.minus(it.first).normalize().times(bezierPoint) + draw3DLine( + if (index != 0) it.first + reduce else it.first, + if (index != pathLines.lastIndex) it.second - reduce else it.second, + color, + lineWidth, + depth + ) + } + path.zipWithNext3().forEach { + val p1 = it.second.minus(it.second.minus(it.first).normalize().times(bezierPoint)) + val p3 = it.second.minus(it.second.minus(it.third).normalize().times(bezierPoint)) + val p2 = it.second + drawBezier2(p1, p2, p3, color, lineWidth, depth) + } + } + } + + fun draw3DLine(p1: LorenzVec, p2: LorenzVec, color: Color, lineWidth: Int, depth: Boolean) { + GL11.glLineWidth(lineWidth.toFloat()) + if (!depth) { + GL11.glDisable(GL11.GL_DEPTH_TEST) + GlStateManager.depthMask(false) + } + GlStateManager.color(color.red / 255f, color.green / 255f, color.blue / 255f, color.alpha / 255f) + worldRenderer.begin(GL11.GL_LINE_STRIP, DefaultVertexFormats.POSITION) + worldRenderer.pos(p1.x, p1.y, p1.z).endVertex() + worldRenderer.pos(p2.x, p2.y, p2.z).endVertex() + tessellator.draw() + if (!depth) { + GL11.glEnable(GL11.GL_DEPTH_TEST) + GlStateManager.depthMask(true) + } + } + + fun drawBezier2( + p1: LorenzVec, + p2: LorenzVec, + p3: LorenzVec, + color: Color, + lineWidth: Int, + depth: Boolean, + segments: Int = 30, + ) { + GL11.glLineWidth(lineWidth.toFloat()) + if (!depth) { + GL11.glDisable(GL11.GL_DEPTH_TEST) + GlStateManager.depthMask(false) + } + GlStateManager.color(color.red / 255f, color.green / 255f, color.blue / 255f, color.alpha / 255f) + val ctrlpoints = p1.toFloatArray() + p2.toFloatArray() + p3.toFloatArray() + bezier2Buffer.clear() + ctrlpoints.forEach { + bezier2Buffer.put(it) + } + bezier2Buffer.flip() + GL11.glMap1f( + GL11.GL_MAP1_VERTEX_3, 0.0f, 1.0f, 3, 3, + bezier2Buffer + ) + + GL11.glEnable(GL11.GL_MAP1_VERTEX_3) + + GL11.glBegin(GL11.GL_LINE_STRIP) + for (i in 0..segments) { + GL11.glEvalCoord1f(i.toFloat() / segments.toFloat()) + } + GL11.glEnd() + if (!depth) { + GL11.glEnable(GL11.GL_DEPTH_TEST) + GlStateManager.depthMask(true) + } + } + + companion object { + inline fun draw3D( + partialTicks: Float = 0F, + crossinline quads: LineDrawer.() -> Unit, + ) { + + GlStateManager.enableBlend() + GlStateManager.disableLighting() + GlStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, 1, 0) + GlStateManager.disableTexture2D() + GlStateManager.disableCull() + GlStateManager.disableAlpha() + + val tessellator = Tessellator.getInstance() + + GlStateManager.pushMatrix() + RenderUtils.translate(getViewerPos(partialTicks).negated()) + getViewerPos(partialTicks) + + quads.invoke(LineDrawer(Tessellator.getInstance())) + + GlStateManager.popMatrix() + + GlStateManager.enableAlpha() + GlStateManager.enableTexture2D() + GlStateManager.enableCull() + GlStateManager.disableBlend() + GlStateManager.color(1.0f, 1.0f, 1.0f, 1.0f) + } + } + } + class QuadDrawer @PublishedApi internal constructor(val tessellator: Tessellator) { val worldRenderer = tessellator.worldRenderer inline fun draw( -- cgit