1.21.3 WIP

1 files changed, 257 insertions, 242 deletions

diff --git a/src/main/kotlin/features/world/Waypoints.kt b/src/main/kotlin/features/world/Waypoints.kt
index d535b4e..72b3c7e 100644
--- a/src/main/kotlin/features/world/Waypoints.kt
+++ b/src/main/kotlin/features/world/Waypoints.kt
@@ -1,5 +1,3 @@
-
-
 package moe.nea.firmament.features.world
 
 import com.mojang.brigadier.arguments.IntegerArgumentType
@@ -12,6 +10,7 @@ import kotlin.collections.set
 import kotlin.time.Duration.Companion.hours
 import kotlin.time.Duration.Companion.seconds
 import net.minecraft.command.argument.BlockPosArgumentType
+import net.minecraft.server.command.CommandOutput
 import net.minecraft.server.command.ServerCommandSource
 import net.minecraft.text.Text
 import net.minecraft.util.math.BlockPos
@@ -35,263 +34,279 @@ import moe.nea.firmament.util.TimeMark
 import moe.nea.firmament.util.render.RenderInWorldContext
 
 object Waypoints : FirmamentFeature {
-    override val identifier: String
-        get() = "waypoints"
+	override val identifier: String
+		get() = "waypoints"
 
-    object TConfig : ManagedConfig(identifier, Category.MINING) { // TODO: add to misc
-        val tempWaypointDuration by duration("temp-waypoint-duration", 0.seconds, 1.hours) { 30.seconds }
-        val showIndex by toggle("show-index") { true }
-        val skipToNearest by toggle("skip-to-nearest") { false }
-        // TODO: look ahead size
-    }
+	object TConfig : ManagedConfig(identifier, Category.MINING) { // TODO: add to misc
+		val tempWaypointDuration by duration("temp-waypoint-duration", 0.seconds, 1.hours) { 30.seconds }
+		val showIndex by toggle("show-index") { true }
+		val skipToNearest by toggle("skip-to-nearest") { false }
+		// TODO: look ahead size
+	}
 
-    data class TemporaryWaypoint(
-        val pos: BlockPos,
-        val postedAt: TimeMark,
-    )
+	data class TemporaryWaypoint(
+		val pos: BlockPos,
+		val postedAt: TimeMark,
+	)
 
-    override val config get() = TConfig
+	override val config get() = TConfig
 
-    val temporaryPlayerWaypointList = mutableMapOf<String, TemporaryWaypoint>()
-    val temporaryPlayerWaypointMatcher = "(?i)x: (-?[0-9]+),? y: (-?[0-9]+),? z: (-?[0-9]+)".toPattern()
+	val temporaryPlayerWaypointList = mutableMapOf<String, TemporaryWaypoint>()
+	val temporaryPlayerWaypointMatcher = "(?i)x: (-?[0-9]+),? y: (-?[0-9]+),? z: (-?[0-9]+)".toPattern()
 
-    val waypoints = mutableListOf<BlockPos>()
-    var ordered = false
-    var orderedIndex = 0
+	val waypoints = mutableListOf<BlockPos>()
+	var ordered = false
+	var orderedIndex = 0
 
-    @Serializable
-    data class ColeWeightWaypoint(
-        val x: Int,
-        val y: Int,
-        val z: Int,
-        val r: Int = 0,
-        val g: Int = 0,
-        val b: Int = 0,
-    )
+	@Serializable
+	data class ColeWeightWaypoint(
+		val x: Int,
+		val y: Int,
+		val z: Int,
+		val r: Int = 0,
+		val g: Int = 0,
+		val b: Int = 0,
+	)
 
-    @Subscribe
-    fun onRenderOrderedWaypoints(event: WorldRenderLastEvent) {
-        if (waypoints.isEmpty()) return
-        RenderInWorldContext.renderInWorld(event) {
-            if (!ordered) {
-                waypoints.withIndex().forEach {
-                    color(0f, 0.3f, 0.7f, 0.5f)
-                    block(it.value)
-                    color(1f, 1f, 1f, 1f)
-                    if (TConfig.showIndex)
-                        withFacingThePlayer(it.value.toCenterPos()) {
-                            text(Text.literal(it.index.toString()))
-                        }
-                }
-            } else {
-                orderedIndex %= waypoints.size
-                val firstColor = Color.ofRGBA(0, 200, 40, 180)
-                color(firstColor)
-                tracer(waypoints[orderedIndex].toCenterPos(), lineWidth = 3f)
-                waypoints.withIndex().toList()
-                    .wrappingWindow(orderedIndex, 3)
-                    .zip(
-                        listOf(
-                            firstColor,
-                            Color.ofRGBA(180, 200, 40, 150),
-                            Color.ofRGBA(180, 80, 20, 140),
-                        )
-                    )
-                    .reversed()
-                    .forEach { (waypoint, col) ->
-                        val (index, pos) = waypoint
-                        color(col)
-                        block(pos)
-                        color(1f, 1f, 1f, 1f)
-                        if (TConfig.showIndex)
-                            withFacingThePlayer(pos.toCenterPos()) {
-                                text(Text.literal(index.toString()))
-                            }
-                    }
-            }
-        }
-    }
+	@Subscribe
+	fun onRenderOrderedWaypoints(event: WorldRenderLastEvent) {
+		if (waypoints.isEmpty()) return
+		RenderInWorldContext.renderInWorld(event) {
+			if (!ordered) {
+				waypoints.withIndex().forEach {
+					color(0f, 0.3f, 0.7f, 0.5f)
+					block(it.value)
+					color(1f, 1f, 1f, 1f)
+					if (TConfig.showIndex)
+						withFacingThePlayer(it.value.toCenterPos()) {
+							text(Text.literal(it.index.toString()))
+						}
+				}
+			} else {
+				orderedIndex %= waypoints.size
+				val firstColor = Color.ofRGBA(0, 200, 40, 180)
+				color(firstColor)
+				tracer(waypoints[orderedIndex].toCenterPos(), lineWidth = 3f)
+				waypoints.withIndex().toList()
+					.wrappingWindow(orderedIndex, 3)
+					.zip(
+						listOf(
+							firstColor,
+							Color.ofRGBA(180, 200, 40, 150),
+							Color.ofRGBA(180, 80, 20, 140),
+						)
+					)
+					.reversed()
+					.forEach { (waypoint, col) ->
+						val (index, pos) = waypoint
+						color(col)
+						block(pos)
+						color(1f, 1f, 1f, 1f)
+						if (TConfig.showIndex)
+							withFacingThePlayer(pos.toCenterPos()) {
+								text(Text.literal(index.toString()))
+							}
+					}
+			}
+		}
+	}
 
-    @Subscribe
-    fun onTick(event: TickEvent) {
-        if (waypoints.isEmpty() || !ordered) return
-        orderedIndex %= waypoints.size
-        val p = MC.player?.pos ?: return
-        if (TConfig.skipToNearest) {
-            orderedIndex =
-                (waypoints.withIndex().minBy { it.value.getSquaredDistance(p) }.index + 1) % waypoints.size
-        } else {
-            if (waypoints[orderedIndex].isWithinDistance(p, 3.0)) {
-                orderedIndex = (orderedIndex + 1) % waypoints.size
-            }
-        }
-    }
+	@Subscribe
+	fun onTick(event: TickEvent) {
+		if (waypoints.isEmpty() || !ordered) return
+		orderedIndex %= waypoints.size
+		val p = MC.player?.pos ?: return
+		if (TConfig.skipToNearest) {
+			orderedIndex =
+				(waypoints.withIndex().minBy { it.value.getSquaredDistance(p) }.index + 1) % waypoints.size
+		} else {
+			if (waypoints[orderedIndex].isWithinDistance(p, 3.0)) {
+				orderedIndex = (orderedIndex + 1) % waypoints.size
+			}
+		}
+	}
 
-    @Subscribe
-    fun onProcessChat(it: ProcessChatEvent) {
-        val matcher = temporaryPlayerWaypointMatcher.matcher(it.unformattedString)
-        if (it.nameHeuristic != null && TConfig.tempWaypointDuration > 0.seconds && matcher.find()) {
-            temporaryPlayerWaypointList[it.nameHeuristic] = TemporaryWaypoint(
-                BlockPos(
-                    matcher.group(1).toInt(),
-                    matcher.group(2).toInt(),
-                    matcher.group(3).toInt(),
-                ),
-                TimeMark.now()
-            )
-        }
-    }
+	@Subscribe
+	fun onProcessChat(it: ProcessChatEvent) {
+		val matcher = temporaryPlayerWaypointMatcher.matcher(it.unformattedString)
+		if (it.nameHeuristic != null && TConfig.tempWaypointDuration > 0.seconds && matcher.find()) {
+			temporaryPlayerWaypointList[it.nameHeuristic] = TemporaryWaypoint(
+				BlockPos(
+					matcher.group(1).toInt(),
+					matcher.group(2).toInt(),
+					matcher.group(3).toInt(),
+				),
+				TimeMark.now()
+			)
+		}
+	}
 
-    @Subscribe
-    fun onCommand(event: CommandEvent.SubCommand) {
-        event.subcommand("waypoint") {
-            thenArgument("pos", BlockPosArgumentType.blockPos()) { pos ->
-                thenExecute {
-                    val position = pos.get(this).toAbsoluteBlockPos(source.asFakeServer())
-                    waypoints.add(position)
-                    source.sendFeedback(
-                        Text.stringifiedTranslatable(
-                            "firmament.command.waypoint.added",
-                            position.x,
-                            position.y,
-                            position.z
-                        )
-                    )
-                }
-            }
-        }
-        event.subcommand("waypoints") {
-            thenLiteral("clear") {
-                thenExecute {
-                    waypoints.clear()
-                    source.sendFeedback(Text.translatable("firmament.command.waypoint.clear"))
-                }
-            }
-            thenLiteral("toggleordered") {
-                thenExecute {
-                    ordered = !ordered
-                    if (ordered) {
-                        val p = MC.player?.pos ?: Vec3d.ZERO
-                        orderedIndex =
-                            waypoints.withIndex().minByOrNull { it.value.getSquaredDistance(p) }?.index ?: 0
-                    }
-                    source.sendFeedback(Text.translatable("firmament.command.waypoint.ordered.toggle.$ordered"))
-                }
-            }
-            thenLiteral("skip") {
-                thenExecute {
-                    if (ordered && waypoints.isNotEmpty()) {
-                        orderedIndex = (orderedIndex + 1) % waypoints.size
-                        source.sendFeedback(Text.translatable("firmament.command.waypoint.skip"))
-                    } else {
-                        source.sendError(Text.translatable("firmament.command.waypoint.skip.error"))
-                    }
-                }
-            }
-            thenLiteral("remove") {
-                thenArgument("index", IntegerArgumentType.integer(0)) { indexArg ->
-                    thenExecute {
-                        val index = get(indexArg)
-                        if (index in waypoints.indices) {
-                            waypoints.removeAt(index)
-                            source.sendFeedback(Text.stringifiedTranslatable(
-                                "firmament.command.waypoint.remove",
-                                index))
-                        } else {
-                            source.sendError(Text.stringifiedTranslatable("firmament.command.waypoint.remove.error"))
-                        }
-                    }
-                }
-            }
-            thenLiteral("import") {
-                thenExecute {
-                    val contents = ClipboardUtils.getTextContents()
-                    val data = try {
-                        Firmament.json.decodeFromString<List<ColeWeightWaypoint>>(contents)
-                    } catch (ex: Exception) {
-                        Firmament.logger.error("Could not load waypoints from clipboard", ex)
-                        source.sendError(Text.translatable("firmament.command.waypoint.import.error"))
-                        return@thenExecute
-                    }
-                    waypoints.clear()
-                    data.mapTo(waypoints) { BlockPos(it.x, it.y, it.z) }
-                    source.sendFeedback(
-                        Text.stringifiedTranslatable(
-                            "firmament.command.waypoint.import",
-                            data.size
-                        )
-                    )
-                }
-            }
-        }
-    }
+	@Subscribe
+	fun onCommand(event: CommandEvent.SubCommand) {
+		event.subcommand("waypoint") {
+			thenArgument("pos", BlockPosArgumentType.blockPos()) { pos ->
+				thenExecute {
+					val position = pos.get(this).toAbsoluteBlockPos(source.asFakeServer())
+					waypoints.add(position)
+					source.sendFeedback(
+						Text.stringifiedTranslatable(
+							"firmament.command.waypoint.added",
+							position.x,
+							position.y,
+							position.z
+						)
+					)
+				}
+			}
+		}
+		event.subcommand("waypoints") {
+			thenLiteral("clear") {
+				thenExecute {
+					waypoints.clear()
+					source.sendFeedback(Text.translatable("firmament.command.waypoint.clear"))
+				}
+			}
+			thenLiteral("toggleordered") {
+				thenExecute {
+					ordered = !ordered
+					if (ordered) {
+						val p = MC.player?.pos ?: Vec3d.ZERO
+						orderedIndex =
+							waypoints.withIndex().minByOrNull { it.value.getSquaredDistance(p) }?.index ?: 0
+					}
+					source.sendFeedback(Text.translatable("firmament.command.waypoint.ordered.toggle.$ordered"))
+				}
+			}
+			thenLiteral("skip") {
+				thenExecute {
+					if (ordered && waypoints.isNotEmpty()) {
+						orderedIndex = (orderedIndex + 1) % waypoints.size
+						source.sendFeedback(Text.translatable("firmament.command.waypoint.skip"))
+					} else {
+						source.sendError(Text.translatable("firmament.command.waypoint.skip.error"))
+					}
+				}
+			}
+			thenLiteral("remove") {
+				thenArgument("index", IntegerArgumentType.integer(0)) { indexArg ->
+					thenExecute {
+						val index = get(indexArg)
+						if (index in waypoints.indices) {
+							waypoints.removeAt(index)
+							source.sendFeedback(Text.stringifiedTranslatable(
+								"firmament.command.waypoint.remove",
+								index))
+						} else {
+							source.sendError(Text.stringifiedTranslatable("firmament.command.waypoint.remove.error"))
+						}
+					}
+				}
+			}
+			thenLiteral("import") {
+				thenExecute {
+					val contents = ClipboardUtils.getTextContents()
+					val data = try {
+						Firmament.json.decodeFromString<List<ColeWeightWaypoint>>(contents)
+					} catch (ex: Exception) {
+						Firmament.logger.error("Could not load waypoints from clipboard", ex)
+						source.sendError(Text.translatable("firmament.command.waypoint.import.error"))
+						return@thenExecute
+					}
+					waypoints.clear()
+					data.mapTo(waypoints) { BlockPos(it.x, it.y, it.z) }
+					source.sendFeedback(
+						Text.stringifiedTranslatable(
+							"firmament.command.waypoint.import",
+							data.size
+						)
+					)
+				}
+			}
+		}
+	}
 
-    @Subscribe
-    fun onRenderTemporaryWaypoints(event: WorldRenderLastEvent) {
-        temporaryPlayerWaypointList.entries.removeIf { it.value.postedAt.passedTime() > TConfig.tempWaypointDuration }
-        if (temporaryPlayerWaypointList.isEmpty()) return
-        RenderInWorldContext.renderInWorld(event) {
-            color(1f, 1f, 0f, 1f)
-            temporaryPlayerWaypointList.forEach { (player, waypoint) ->
-                block(waypoint.pos)
-            }
-            color(1f, 1f, 1f, 1f)
-            temporaryPlayerWaypointList.forEach { (player, waypoint) ->
-                val skin =
-                    MC.networkHandler?.listedPlayerListEntries?.find { it.profile.name == player }
-                        ?.skinTextures
-                        ?.texture
-                withFacingThePlayer(waypoint.pos.toCenterPos()) {
-                    waypoint(waypoint.pos, Text.stringifiedTranslatable("firmament.waypoint.temporary", player))
-                    if (skin != null) {
-                        matrixStack.translate(0F, -20F, 0F)
-                        // Head front
-                        texture(
-                            skin, 16, 16,
-                            1 / 8f, 1 / 8f,
-                            2 / 8f, 2 / 8f,
-                        )
-                        // Head overlay
-                        texture(
-                            skin, 16, 16,
-                            5 / 8f, 1 / 8f,
-                            6 / 8f, 2 / 8f,
-                        )
-                    }
-                }
-            }
-        }
-    }
+	@Subscribe
+	fun onRenderTemporaryWaypoints(event: WorldRenderLastEvent) {
+		temporaryPlayerWaypointList.entries.removeIf { it.value.postedAt.passedTime() > TConfig.tempWaypointDuration }
+		if (temporaryPlayerWaypointList.isEmpty()) return
+		RenderInWorldContext.renderInWorld(event) {
+			color(1f, 1f, 0f, 1f)
+			temporaryPlayerWaypointList.forEach { (player, waypoint) ->
+				block(waypoint.pos)
+			}
+			color(1f, 1f, 1f, 1f)
+			temporaryPlayerWaypointList.forEach { (player, waypoint) ->
+				val skin =
+					MC.networkHandler?.listedPlayerListEntries?.find { it.profile.name == player }
+						?.skinTextures
+						?.texture
+				withFacingThePlayer(waypoint.pos.toCenterPos()) {
+					waypoint(waypoint.pos, Text.stringifiedTranslatable("firmament.waypoint.temporary", player))
+					if (skin != null) {
+						matrixStack.translate(0F, -20F, 0F)
+						// Head front
+						texture(
+							skin, 16, 16,
+							1 / 8f, 1 / 8f,
+							2 / 8f, 2 / 8f,
+						)
+						// Head overlay
+						texture(
+							skin, 16, 16,
+							5 / 8f, 1 / 8f,
+							6 / 8f, 2 / 8f,
+						)
+					}
+				}
+			}
+		}
+	}
 
-    @Subscribe
-    fun onWorldReady(event: WorldReadyEvent) {
-        temporaryPlayerWaypointList.clear()
-    }
+	@Subscribe
+	fun onWorldReady(event: WorldReadyEvent) {
+		temporaryPlayerWaypointList.clear()
+	}
 }
 
 fun <E> List<E>.wrappingWindow(startIndex: Int, windowSize: Int): List<E> {
-    val result = ArrayList<E>(windowSize)
-    if (startIndex + windowSize < size) {
-        result.addAll(subList(startIndex, startIndex + windowSize))
-    } else {
-        result.addAll(subList(startIndex, size))
-        result.addAll(subList(0, minOf(windowSize - (size - startIndex), startIndex)))
-    }
-    return result
+	val result = ArrayList<E>(windowSize)
+	if (startIndex + windowSize < size) {
+		result.addAll(subList(startIndex, startIndex + windowSize))
+	} else {
+		result.addAll(subList(startIndex, size))
+		result.addAll(subList(0, minOf(windowSize - (size - startIndex), startIndex)))
+	}
+	return result
 }
 
 
 fun FabricClientCommandSource.asFakeServer(): ServerCommandSource {
-    val source = this
-    return ServerCommandSource(
-        source.player,
-        source.position,
-        source.rotation,
-        null,
-        0,
-        "FakeServerCommandSource",
-        Text.literal("FakeServerCommandSource"),
-        null,
-        source.player
-    )
+	val source = this
+	return ServerCommandSource(
+		object : CommandOutput {
+			override fun sendMessage(message: Text?) {
+				source.player.sendMessage(message, false)
+			}
+
+			override fun shouldReceiveFeedback(): Boolean {
+				return true
+			}
+
+			override fun shouldTrackOutput(): Boolean {
+				return true
+			}
+
+			override fun shouldBroadcastConsoleToOps(): Boolean {
+				return true
+			}
+		},
+		source.position,
+		source.rotation,
+		null,
+		0,
+		"FakeServerCommandSource",
+		Text.literal("FakeServerCommandSource"),
+		null,
+		source.player
+	)
 }