Merge pull request #10 from NotAlexNoyle/main

Merge changes from upstream

build.gradle.kts

@@ -3,6 +3,7 @@ import java.io.BufferedReader
 plugins {
     kotlin("jvm") version "2.1.21"
     id("com.gradleup.shadow") version "8.3.6"
+    id("com.diffplug.spotless") version "7.0.4"
 }
 
 val commitHash = Runtime
@@ -59,6 +60,7 @@ kotlin {
 }
 
 tasks.build {
+    dependsOn(tasks.spotlessApply)
     dependsOn(tasks.shadowJar)
 }
 
@@ -98,3 +100,11 @@ java {
         vendor = JvmVendorSpec.GRAAL_VM
     }
 }
+
+spotless {
+    kotlin {
+        ktfmt().kotlinlangStyle().configure {
+            it.setMaxWidth(120)
+        }
+    }
+}

src/main/kotlin/net/trueog/questsOG/ClaimQuest.kt

@@ -8,12 +8,7 @@ import org.bukkit.command.CommandSender
 import org.bukkit.entity.Player
 
 class ClaimQuest : CommandExecutor {
-    override fun onCommand(
-        sender: CommandSender,
-        command: Command,
-        label: String,
-        args: Array<out String>?
-    ): Boolean {
+    override fun onCommand(sender: CommandSender, command: Command, label: String, args: Array<out String>?): Boolean {
         if (sender !is Player) {
             sender.sendMessage("You can only execute this command as a player.")
             return true
@@ -50,10 +45,12 @@ class ClaimQuest : CommandExecutor {
                 var requirementsMessage = ""
                 for (requirement in requirements) {
                     if (requirement is BooleanRequirement) {
-                        requirementsMessage += "${if (requirement.met) "<green>" else "<red>"}${requirement.name}: ${requirement.met}<reset> |"
+                        requirementsMessage +=
+                            "${if (requirement.met) "<green>" else "<red>"}${requirement.name}: ${requirement.met}<reset> |"
                     }
                     if (requirement is ProgressRequirement) {
-                        requirementsMessage += "${if (requirement.current >= requirement.target) "<green>" else "<red>"}${requirement.name}: ${requirement.current}/${requirement.target}<reset> | "
+                        requirementsMessage +=
+                            "${if (requirement.current >= requirement.target) "<green>" else "<red>"}${requirement.name}: ${requirement.current}/${requirement.target}<reset> | "
                     }
                 }
                 sender.sendMessage(QuestsOG.mm.deserialize(requirementsMessage))
@@ -61,5 +58,4 @@ class ClaimQuest : CommandExecutor {
         }
         return true
     }
-
-}
+}

src/main/kotlin/net/trueog/questsOG/Config.kt

@@ -1,21 +1,18 @@
 package net.trueog.questsOG
 
-import org.bukkit.configuration.file.YamlConfiguration
 import java.io.File
+import org.bukkit.configuration.file.YamlConfiguration
 
 class Config {
     lateinit var redisUrl: String
 
-    /**
-     * @return True if successful
-     */
+    /** @return True if successful */
     fun load(): Boolean {
         val file = File(QuestsOG.plugin.dataFolder, "config.yml")
         if (!file.exists()) {
             QuestsOG.plugin.saveDefaultConfig()
         }
         val config = YamlConfiguration.loadConfiguration(file)
-        config.save(file)
 
         try {
             redisUrl = config.get("redisUrl") as String
@@ -26,4 +23,4 @@ class Config {
 
         return true
     }
-}
+}

src/main/kotlin/net/trueog/questsOG/Events.kt

@@ -22,12 +22,16 @@ class Events : Listener {
 
         val translatableDeathMessageArgs = translatableDeathMessage.args()
 
-        if (translatableDeathMessage.key() == "death.attack.hotFloor.player" && translatableDeathMessageArgs.size >= 2 && (translatableDeathMessageArgs[1] as TranslatableComponent).key() == "entity.minecraft.zoglin") {
+        if (
+            translatableDeathMessage.key() == "death.attack.hotFloor.player" &&
+                translatableDeathMessageArgs.size >= 2 &&
+                (translatableDeathMessageArgs[1] as TranslatableComponent).key() == "entity.minecraft.zoglin"
+        ) {
             QuestsOG.redis.setValue(
                 "questsog:${event.player.uniqueId}:deaths:diedToMagmaBlockWhileFightingZoglin",
-                "true"
+                "true",
             )
             return
         }
     }
-}
+}

src/main/kotlin/net/trueog/questsOG/MainThreadBlock.kt

@@ -1,9 +1,9 @@
 package net.trueog.questsOG
 
-import kotlinx.coroutines.suspendCancellableCoroutine
-import org.bukkit.Bukkit
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
+import kotlinx.coroutines.suspendCancellableCoroutine
+import org.bukkit.Bukkit
 
 object MainThreadBlock {
     suspend fun <T> runOnMainThread(block: () -> T): T {
@@ -11,14 +11,18 @@ object MainThreadBlock {
             block()
         } else {
             suspendCancellableCoroutine { cont ->
-                Bukkit.getScheduler().runTask(QuestsOG.plugin, Runnable {
-                    try {
-                        cont.resume(block())
-                    } catch (e: Throwable) {
-                        cont.resumeWithException(e)
-                    }
-                })
+                Bukkit.getScheduler()
+                    .runTask(
+                        QuestsOG.plugin,
+                        Runnable {
+                            try {
+                                cont.resume(block())
+                            } catch (e: Throwable) {
+                                cont.resumeWithException(e)
+                            }
+                        },
+                    )
             }
         }
     }
-}
+}

src/main/kotlin/net/trueog/questsOG/QuestsOG.kt

@@ -11,7 +11,6 @@ import org.bukkit.Bukkit
 import org.bukkit.plugin.Plugin
 import org.bukkit.plugin.java.JavaPlugin
 
-
 class QuestsOG : JavaPlugin() {
     companion object {
         val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
@@ -23,14 +22,10 @@ class QuestsOG : JavaPlugin() {
         lateinit var luckPerms: LuckPerms
         lateinit var duels: Duels
         lateinit var mobHeads: Plugin
-        var mm = MiniMessage.builder()
-            .tags(
-                TagResolver.builder()
-                    .resolver(StandardTags.color())
-                    .resolver(StandardTags.reset())
-                    .build()
-            )
-            .build()
+        var mm =
+            MiniMessage.builder()
+                .tags(TagResolver.builder().resolver(StandardTags.color()).resolver(StandardTags.reset()).build())
+                .build()
     }
 
     override fun onEnable() {
@@ -49,8 +44,7 @@ class QuestsOG : JavaPlugin() {
             return
         }
 
-        val diamondBankAPIProvider =
-            server.servicesManager.getRegistration(DiamondBankAPIKotlin::class.java)
+        val diamondBankAPIProvider = server.servicesManager.getRegistration(DiamondBankAPIKotlin::class.java)
         if (diamondBankAPIProvider == null) {
             logger.severe("DiamondBank-OG API is null")
             Bukkit.getPluginManager().disablePlugin(this)
@@ -91,8 +85,6 @@ class QuestsOG : JavaPlugin() {
 
         scope.cancel()
 
-        runBlocking {
-            scope.coroutineContext[Job]?.join()
-        }
+        runBlocking { scope.coroutineContext[Job]?.join() }
     }
 }

src/main/kotlin/net/trueog/questsOG/Redis.kt

@@ -6,9 +6,7 @@ import io.lettuce.core.RedisConnectionException
 class Redis {
     private val redisClient: RedisClient = RedisClient.create(QuestsOG.config.redisUrl)
 
-    /**
-     * @return True if successful
-     */
+    /** @return True if successful */
     fun testConnection(): Boolean {
         try {
             val connection = redisClient.connect()
@@ -37,4 +35,4 @@ class Redis {
     fun shutdown() {
         redisClient.shutdown()
     }
-}
+}

src/main/kotlin/net/trueog/questsOG/Requirement.kt

@@ -4,4 +4,4 @@ open class Requirement(val name: String)
 
 class ProgressRequirement(name: String, val current: Int, val target: Int) : Requirement(name)
 
-class BooleanRequirement(name: String, val met: Boolean) : Requirement(name)
+class BooleanRequirement(name: String, val met: Boolean) : Requirement(name)

src/main/kotlin/net/trueog/questsOG/progression/HomesProgression.kt

@@ -8,7 +8,9 @@ object HomesProgression : Progression {
 
     override fun getNextQuest(player: Player): Quest? {
         val homePermission =
-            player.effectivePermissions.singleOrNull { permission -> permission.permission.startsWith("essentials.sethome.multiple.homes-") }
+            player.effectivePermissions.singleOrNull { permission ->
+                permission.permission.startsWith("essentials.sethome.multiple.homes-")
+            }
         val nextQuestIndex = homePermission?.permission?.takeLast(1)?.toInt()?.minus(1) ?: 0
 
         if (nextQuestIndex + 1 > quests.size) {
@@ -17,4 +19,4 @@ object HomesProgression : Progression {
 
         return quests[nextQuestIndex]
     }
-}
+}

src/main/kotlin/net/trueog/questsOG/progression/Progression.kt

@@ -7,4 +7,4 @@ interface Progression {
     val quests: Array<Quest>
 
     fun getNextQuest(player: Player): Quest?
-}
+}

src/main/kotlin/net/trueog/questsOG/quests/HomesFive.kt

@@ -31,25 +31,34 @@ class HomesFive : Quest {
         val levels: Int,
         val fishCaught: Int,
         val hasVillagerHead: Boolean,
-        val duelsWins: Int
+        val duelsWins: Int,
     )
 
     val customMobHeadKey = NamespacedKey(QuestsOG.mobHeads, "customMobHead")
 
-    private val cutestPredatorAdvancement = Bukkit.getServer().advancementIterator().asSequence()
-        .single { advancement -> advancement.key.toString() == "minecraft:husbandry/axolotl_in_a_bucket" }
-    private val twoByTwoAdvancement = Bukkit.getServer().advancementIterator().asSequence()
-        .single { advancement -> advancement.key.toString() == "minecraft:husbandry/bred_all_animals" }
-    private val completeCatalogueAdvancement = Bukkit.getServer().advancementIterator().asSequence()
-        .single { advancement -> advancement.key.toString() == "minecraft:husbandry/complete_catalogue" }
-    private val monstersHuntedAdvancement = Bukkit.getServer().advancementIterator().asSequence()
-        .single { advancement -> advancement.key.toString() == "minecraft:adventure/kill_all_mobs" }
+    private val cutestPredatorAdvancement =
+        Bukkit.getServer().advancementIterator().asSequence().single { advancement ->
+            advancement.key.toString() == "minecraft:husbandry/axolotl_in_a_bucket"
+        }
+    private val twoByTwoAdvancement =
+        Bukkit.getServer().advancementIterator().asSequence().single { advancement ->
+            advancement.key.toString() == "minecraft:husbandry/bred_all_animals"
+        }
+    private val completeCatalogueAdvancement =
+        Bukkit.getServer().advancementIterator().asSequence().single { advancement ->
+            advancement.key.toString() == "minecraft:husbandry/complete_catalogue"
+        }
+    private val monstersHuntedAdvancement =
+        Bukkit.getServer().advancementIterator().asSequence().single { advancement ->
+            advancement.key.toString() == "minecraft:adventure/kill_all_mobs"
+        }
 
     private suspend fun fetchRequirements(player: Player): Requirements? {
         val playerShardsResult = QuestsOG.diamondBankAPI.getPlayerShards(player.uniqueId, PostgreSQL.ShardType.ALL)
-        val playerShards = playerShardsResult.getOrElse {
-            return null
-        }
+        val playerShards =
+            playerShardsResult.getOrElse {
+                return null
+            }
         if (playerShards.isNeededShardTypeNull(PostgreSQL.ShardType.ALL)) {
             return null
         }
@@ -81,10 +90,11 @@ class HomesFive : Quest {
 
         val fishCaught = player.getStatistic(Statistic.FISH_CAUGHT)
 
-        val hasVillagerHead = player.inventory.filterNotNull().any {
-            val data = it.itemMeta.persistentDataContainer.get(customMobHeadKey, PersistentDataType.STRING)
-            data?.startsWith("VILLAGER") == true
-        }
+        val hasVillagerHead =
+            player.inventory.filterNotNull().any {
+                val data = it.itemMeta.persistentDataContainer.get(customMobHeadKey, PersistentDataType.STRING)
+                data?.startsWith("VILLAGER") == true
+            }
 
         val duelsWins = QuestsOG.duels.userManager.get(player.uniqueId)?.wins ?: 0
 
@@ -104,7 +114,7 @@ class HomesFive : Quest {
             player.level,
             fishCaught,
             hasVillagerHead,
-            duelsWins
+            duelsWins,
         )
     }
 
@@ -116,21 +126,21 @@ class HomesFive : Quest {
         }
 
         return requirements.totalShards >= 2500 * 9 &&
-                requirements.ticksPlayed / 20.0 / 60.0 / 60.0 / 24.0 >= 15 &&
-                requirements.pigOneCm / 100000.0 >= 5 &&
-                requirements.striderOneCm / 100000.0 >= 1 &&
-                requirements.dolphinKills >= 50 &&
-                requirements.zoglinKills >= 50 &&
-                requirements.hasCutestPredator &&
-                requirements.hasTwoByTwo &&
-                requirements.hasCompleteCatalogue &&
-                requirements.hasMonstersHunted &&
-                requirements.hasDiedToFellWhileClimbing &&
-                requirements.hasDiedToMagmaBlockWhileFightingZoglin &&
-                requirements.levels >= 200 &&
-                requirements.fishCaught >= 2000 &&
-                requirements.hasVillagerHead &&
-                requirements.duelsWins >= 150
+            requirements.ticksPlayed / 20.0 / 60.0 / 60.0 / 24.0 >= 15 &&
+            requirements.pigOneCm / 100000.0 >= 5 &&
+            requirements.striderOneCm / 100000.0 >= 1 &&
+            requirements.dolphinKills >= 50 &&
+            requirements.zoglinKills >= 50 &&
+            requirements.hasCutestPredator &&
+            requirements.hasTwoByTwo &&
+            requirements.hasCompleteCatalogue &&
+            requirements.hasMonstersHunted &&
+            requirements.hasDiedToFellWhileClimbing &&
+            requirements.hasDiedToMagmaBlockWhileFightingZoglin &&
+            requirements.levels >= 200 &&
+            requirements.fishCaught >= 2000 &&
+            requirements.hasVillagerHead &&
+            requirements.duelsWins >= 150
     }
 
     override suspend fun consumeQuestItems(player: Player): Boolean {
@@ -140,9 +150,7 @@ class HomesFive : Quest {
             return false
         }
 
-        runOnMainThread {
-            player.level -= 200
-        }
+        runOnMainThread { player.level -= 200 }
 
         return true
     }
@@ -178,12 +186,12 @@ class HomesFive : Quest {
             BooleanRequirement("Died to \"fell while climbing\"", requirements.hasDiedToFellWhileClimbing),
             BooleanRequirement(
                 "Died to \"walked into the danger zone due to Zoglin\"",
-                requirements.hasDiedToMagmaBlockWhileFightingZoglin
+                requirements.hasDiedToMagmaBlockWhileFightingZoglin,
             ),
             ProgressRequirement("Levels", requirements.levels, 200),
             ProgressRequirement("Fish Caught", requirements.fishCaught, 2000),
             BooleanRequirement("Has Villager Head", requirements.hasVillagerHead),
-            ProgressRequirement("Duels Wins", requirements.duelsWins, 150)
+            ProgressRequirement("Duels Wins", requirements.duelsWins, 150),
         )
     }
-}
+}

src/main/kotlin/net/trueog/questsOG/quests/HomesFour.kt

@@ -20,19 +20,24 @@ class HomesFour : Quest {
         val hasSeriousDedication: Boolean,
         val levels: Int,
         val hasDiedToFellAccidentWater: Boolean,
-        val duelsWins: Int
+        val duelsWins: Int,
     )
 
-    private val furiousCocktailAdvancement = Bukkit.getServer().advancementIterator().asSequence()
-        .single { it.key.toString() == "minecraft:nether/all_potions" }
-    private val seriousDedicationAdvancement = Bukkit.getServer().advancementIterator().asSequence()
-        .single { it.key.toString() == "minecraft:husbandry/obtain_netherite_hoe" }
+    private val furiousCocktailAdvancement =
+        Bukkit.getServer().advancementIterator().asSequence().single {
+            it.key.toString() == "minecraft:nether/all_potions"
+        }
+    private val seriousDedicationAdvancement =
+        Bukkit.getServer().advancementIterator().asSequence().single {
+            it.key.toString() == "minecraft:husbandry/obtain_netherite_hoe"
+        }
 
     private suspend fun fetchRequirements(player: Player): Requirements? {
         val playerShardsResult = QuestsOG.diamondBankAPI.getPlayerShards(player.uniqueId, PostgreSQL.ShardType.ALL)
-        val playerShards = playerShardsResult.getOrElse {
-            return null
-        }
+        val playerShards =
+            playerShardsResult.getOrElse {
+                return null
+            }
         if (playerShards.isNeededShardTypeNull(PostgreSQL.ShardType.ALL)) {
             return null
         }
@@ -55,7 +60,19 @@ class HomesFour : Quest {
         val swimOneCm = player.getStatistic(Statistic.SWIM_ONE_CM)
         val striderOneCm = player.getStatistic(Statistic.STRIDER_ONE_CM)
         val totalCm =
-            walkOneCm + walkOnWaterOneCm + climbOneCm + walkUnderWaterOneCm + minecartOneCm + boatOneCm + pigOneCm + horseOneCm + sprintOneCm + crouchOneCm + aviateOneCm + swimOneCm + striderOneCm
+            walkOneCm +
+                walkOnWaterOneCm +
+                climbOneCm +
+                walkUnderWaterOneCm +
+                minecartOneCm +
+                boatOneCm +
+                pigOneCm +
+                horseOneCm +
+                sprintOneCm +
+                crouchOneCm +
+                aviateOneCm +
+                swimOneCm +
+                striderOneCm
 
         val furiousCocktailAdvancementProgress = player.getAdvancementProgress(furiousCocktailAdvancement)
 
@@ -74,7 +91,7 @@ class HomesFour : Quest {
             seriousDedicationAdvancementProgress.isDone,
             player.level,
             hasDiedToFellAccidentWater,
-            duelsWins
+            duelsWins,
         )
     }
 
@@ -86,13 +103,13 @@ class HomesFour : Quest {
         }
 
         return requirements.totalShards >= 1000 * 9 &&
-                requirements.ticksPlayed / 20.0 / 60.0 / 60.0 / 24.0 >= 10 &&
-                requirements.totalCm / 100.0 >= 200000 &&
-                requirements.hasFuriousCocktail &&
-                requirements.hasSeriousDedication &&
-                requirements.levels >= 150 &&
-                requirements.hasDiedToFellAccidentWater &&
-                requirements.duelsWins >= 50
+            requirements.ticksPlayed / 20.0 / 60.0 / 60.0 / 24.0 >= 10 &&
+            requirements.totalCm / 100.0 >= 200000 &&
+            requirements.hasFuriousCocktail &&
+            requirements.hasSeriousDedication &&
+            requirements.levels >= 150 &&
+            requirements.hasDiedToFellAccidentWater &&
+            requirements.duelsWins >= 50
     }
 
     override suspend fun consumeQuestItems(player: Player): Boolean {
@@ -102,9 +119,7 @@ class HomesFour : Quest {
             return false
         }
 
-        runOnMainThread {
-            player.level -= 150
-        }
+        runOnMainThread { player.level -= 150 }
 
         return true
     }
@@ -134,7 +149,7 @@ class HomesFour : Quest {
             BooleanRequirement("Serious Dedication", requirements.hasSeriousDedication),
             ProgressRequirement("Levels", requirements.levels, 150),
             BooleanRequirement("Died to \"death.fell.accident.water\"", requirements.hasDiedToFellAccidentWater),
-            ProgressRequirement("Duels Wins", requirements.duelsWins, 50)
+            ProgressRequirement("Duels Wins", requirements.duelsWins, 50),
         )
     }
-}
+}

src/main/kotlin/net/trueog/questsOG/quests/HomesSix.kt

@@ -20,35 +20,37 @@ class HomesSix : Quest {
         val walkUnderWaterOneCm: Int,
         val stoneLikePickedUp: Int,
         val discs: Int,
-//        val hasLeftConfinesOfWorldWhileFightingEnderDragon: Boolean,
+        //        val hasLeftConfinesOfWorldWhileFightingEnderDragon: Boolean,
         val finishedAdvancements: Int,
         val obsidianMined: Int,
         val dragonEggs: Int,
         val levels: Int,
-        val duelsWins: Int
+        val duelsWins: Int,
     )
 
-    private val neededDiscs = setOf(
-        Material.MUSIC_DISC_13,
-        Material.MUSIC_DISC_CAT,
-        Material.MUSIC_DISC_BLOCKS,
-        Material.MUSIC_DISC_CHIRP,
-        Material.MUSIC_DISC_FAR,
-        Material.MUSIC_DISC_MALL,
-        Material.MUSIC_DISC_MELLOHI,
-        Material.MUSIC_DISC_STAL,
-        Material.MUSIC_DISC_STRAD,
-        Material.MUSIC_DISC_WARD,
-        Material.MUSIC_DISC_11,
-        Material.MUSIC_DISC_WAIT,
-        Material.MUSIC_DISC_5
-    )
+    private val neededDiscs =
+        setOf(
+            Material.MUSIC_DISC_13,
+            Material.MUSIC_DISC_CAT,
+            Material.MUSIC_DISC_BLOCKS,
+            Material.MUSIC_DISC_CHIRP,
+            Material.MUSIC_DISC_FAR,
+            Material.MUSIC_DISC_MALL,
+            Material.MUSIC_DISC_MELLOHI,
+            Material.MUSIC_DISC_STAL,
+            Material.MUSIC_DISC_STRAD,
+            Material.MUSIC_DISC_WARD,
+            Material.MUSIC_DISC_11,
+            Material.MUSIC_DISC_WAIT,
+            Material.MUSIC_DISC_5,
+        )
 
     private suspend fun fetchRequirements(player: Player): Requirements? {
         val playerShardsResult = QuestsOG.diamondBankAPI.getPlayerShards(player.uniqueId, PostgreSQL.ShardType.ALL)
-        val playerShards = playerShardsResult.getOrElse {
-            return null
-        }
+        val playerShards =
+            playerShardsResult.getOrElse {
+                return null
+            }
         if (playerShards.isNeededShardTypeNull(PostgreSQL.ShardType.ALL)) {
             return null
         }
@@ -65,15 +67,17 @@ class HomesSix : Quest {
         val cobblestoneMined = player.getStatistic(Statistic.MINE_BLOCK, Material.COBBLESTONE)
         val stoneLikeMined = stoneMined + cobblestoneMined
 
-        val discs = player.inventory
-            .filterNotNull()
-            .filter { it.type in neededDiscs }.distinctBy { it.type }
+        val discs = player.inventory.filterNotNull().filter { it.type in neededDiscs }.distinctBy { it.type }
 
-//        val hasLeftConfinesOfWorldWhileFightingEnderDragon =
-//            QuestsOG.redis.getValue("questsog:${player.uniqueId}:deaths:leftConfinesOfWorldWhileFightingEnderDragon") == "true"
+        //        val hasLeftConfinesOfWorldWhileFightingEnderDragon =
+        //
+        // QuestsOG.redis.getValue("questsog:${player.uniqueId}:deaths:leftConfinesOfWorldWhileFightingEnderDragon") ==
+        // "true"
 
-        val finishedAdvancements = Bukkit.getServer().advancementIterator().asSequence().filterNotNull()
-            .filter { player.getAdvancementProgress(it).isDone }
+        val finishedAdvancements =
+            Bukkit.getServer().advancementIterator().asSequence().filterNotNull().filter {
+                player.getAdvancementProgress(it).isDone
+            }
 
         val obsidianMined = player.getStatistic(Statistic.MINE_BLOCK, Material.OBSIDIAN)
 
@@ -88,12 +92,12 @@ class HomesSix : Quest {
             walkUnderWaterOneCm,
             stoneLikeMined,
             discs.size,
-//            hasLeftConfinesOfWorldWhileFightingEnderDragon,
+            //            hasLeftConfinesOfWorldWhileFightingEnderDragon,
             finishedAdvancements.count(),
             obsidianMined,
             dragonEggs,
             player.level,
-            duelsWins
+            duelsWins,
         )
     }
 
@@ -105,16 +109,16 @@ class HomesSix : Quest {
         }
 
         return requirements.totalShards >= 5000 * 9 &&
-                requirements.ticksPlayed / 20.0 / 60.0 / 60.0 / 24.0 >= 30 &&
-                requirements.walkOnWaterOneCm / 100000.0 >= 10 &&
-                requirements.walkUnderWaterOneCm / 100000.0 >= 10 &&
-                requirements.discs >= 13 &&
-//                requirements.hasLeftConfinesOfWorldWhileFightingEnderDragon &&
-                requirements.finishedAdvancements >= 1179 &&
-                requirements.obsidianMined >= 1500 &&
-                requirements.dragonEggs >= 5 &&
-                requirements.levels >= 250 &&
-                requirements.duelsWins >= 300
+            requirements.ticksPlayed / 20.0 / 60.0 / 60.0 / 24.0 >= 30 &&
+            requirements.walkOnWaterOneCm / 100000.0 >= 10 &&
+            requirements.walkUnderWaterOneCm / 100000.0 >= 10 &&
+            requirements.discs >= 13 &&
+            //                requirements.hasLeftConfinesOfWorldWhileFightingEnderDragon &&
+            requirements.finishedAdvancements >= 1179 &&
+            requirements.obsidianMined >= 1500 &&
+            requirements.dragonEggs >= 5 &&
+            requirements.levels >= 250 &&
+            requirements.duelsWins >= 300
     }
 
     override suspend fun consumeQuestItems(player: Player): Boolean {
@@ -169,7 +173,7 @@ class HomesSix : Quest {
             ProgressRequirement("Obsidian Mined", requirements.obsidianMined, 1500),
             ProgressRequirement("Dragon Eggs", requirements.dragonEggs, 5),
             ProgressRequirement("Levels", requirements.levels, 250),
-            ProgressRequirement("Duels Wins", requirements.duelsWins, 300)
+            ProgressRequirement("Duels Wins", requirements.duelsWins, 300),
         )
     }
-}
+}

src/main/kotlin/net/trueog/questsOG/quests/HomesThree.kt

@@ -18,17 +18,20 @@ class HomesThree : Quest {
         val totalCm: Int,
         val hasBeaconator: Boolean,
         val levels: Int,
-        val duelsWins: Int
+        val duelsWins: Int,
     )
 
-    private val beaconatorAdvancement = Bukkit.getServer().advancementIterator().asSequence()
-        .single { it.key.toString() == "minecraft:nether/create_full_beacon" }
+    private val beaconatorAdvancement =
+        Bukkit.getServer().advancementIterator().asSequence().single {
+            it.key.toString() == "minecraft:nether/create_full_beacon"
+        }
 
     private suspend fun fetchRequirements(player: Player): Requirements? {
         val playerShardsResult = QuestsOG.diamondBankAPI.getPlayerShards(player.uniqueId, PostgreSQL.ShardType.ALL)
-        val playerShards = playerShardsResult.getOrElse {
-            return null
-        }
+        val playerShards =
+            playerShardsResult.getOrElse {
+                return null
+            }
         if (playerShards.isNeededShardTypeNull(PostgreSQL.ShardType.ALL)) {
             return null
         }
@@ -51,20 +54,25 @@ class HomesThree : Quest {
         val swimOneCm = player.getStatistic(Statistic.SWIM_ONE_CM)
         val striderOneCm = player.getStatistic(Statistic.STRIDER_ONE_CM)
         val totalCm =
-            walkOneCm + walkOnWaterOneCm + climbOneCm + walkUnderWaterOneCm + minecartOneCm + boatOneCm + pigOneCm + horseOneCm + sprintOneCm + crouchOneCm + aviateOneCm + swimOneCm + striderOneCm
+            walkOneCm +
+                walkOnWaterOneCm +
+                climbOneCm +
+                walkUnderWaterOneCm +
+                minecartOneCm +
+                boatOneCm +
+                pigOneCm +
+                horseOneCm +
+                sprintOneCm +
+                crouchOneCm +
+                aviateOneCm +
+                swimOneCm +
+                striderOneCm
 
         val advancementProgress = player.getAdvancementProgress(beaconatorAdvancement)
 
         val duelsWins = QuestsOG.duels.userManager.get(player.uniqueId)?.wins ?: 0
 
-        return Requirements(
-            totalShards,
-            ticksPlayed,
-            totalCm,
-            advancementProgress.isDone,
-            player.level,
-            duelsWins
-        )
+        return Requirements(totalShards, ticksPlayed, totalCm, advancementProgress.isDone, player.level, duelsWins)
     }
 
     override suspend fun isEligible(player: Player): Boolean? {
@@ -75,11 +83,11 @@ class HomesThree : Quest {
         }
 
         return requirements.totalShards >= 250 * 9 &&
-                requirements.ticksPlayed / 20.0 / 60.0 / 60.0 / 24.0 >= 5 &&
-                requirements.totalCm / 100.0 >= 50000 && // 100k?
-                requirements.hasBeaconator &&
-                requirements.levels >= 100 &&
-                requirements.duelsWins >= 20
+            requirements.ticksPlayed / 20.0 / 60.0 / 60.0 / 24.0 >= 5 &&
+            requirements.totalCm / 100.0 >= 50000 && // 100k?
+            requirements.hasBeaconator &&
+            requirements.levels >= 100 &&
+            requirements.duelsWins >= 20
     }
 
     override suspend fun consumeQuestItems(player: Player): Boolean {
@@ -89,9 +97,7 @@ class HomesThree : Quest {
             return false
         }
 
-        runOnMainThread {
-            player.level -= 100
-        }
+        runOnMainThread { player.level -= 100 }
 
         return true
     }
@@ -119,7 +125,7 @@ class HomesThree : Quest {
             ProgressRequirement("Total Cm Travelled", requirements.totalCm, 5000000),
             BooleanRequirement("Beaconator", requirements.hasBeaconator),
             ProgressRequirement("Levels", requirements.levels, 100),
-            ProgressRequirement("Duels Wins", requirements.duelsWins, 20)
+            ProgressRequirement("Duels Wins", requirements.duelsWins, 20),
         )
     }
-}
+}

src/main/kotlin/net/trueog/questsOG/quests/HomesTwo.kt

@@ -15,14 +15,15 @@ class HomesTwo : Quest {
         val ticksPlayed: Int,
         val totalCm: Int,
         val levels: Int,
-        val duelsWins: Int
+        val duelsWins: Int,
     )
 
     private suspend fun fetchRequirements(player: Player): Requirements? {
         val playerShardsResult = QuestsOG.diamondBankAPI.getPlayerShards(player.uniqueId, PostgreSQL.ShardType.ALL)
-        val playerShards = playerShardsResult.getOrElse {
-            return null
-        }
+        val playerShards =
+            playerShardsResult.getOrElse {
+                return null
+            }
         if (playerShards.isNeededShardTypeNull(PostgreSQL.ShardType.ALL)) {
             return null
         }
@@ -45,7 +46,19 @@ class HomesTwo : Quest {
         val swimOneCm = player.getStatistic(Statistic.SWIM_ONE_CM)
         val striderOneCm = player.getStatistic(Statistic.STRIDER_ONE_CM)
         val totalCm =
-            walkOneCm + walkOnWaterOneCm + climbOneCm + walkUnderWaterOneCm + minecartOneCm + boatOneCm + pigOneCm + horseOneCm + sprintOneCm + crouchOneCm + aviateOneCm + swimOneCm + striderOneCm
+            walkOneCm +
+                walkOnWaterOneCm +
+                climbOneCm +
+                walkUnderWaterOneCm +
+                minecartOneCm +
+                boatOneCm +
+                pigOneCm +
+                horseOneCm +
+                sprintOneCm +
+                crouchOneCm +
+                aviateOneCm +
+                swimOneCm +
+                striderOneCm
 
         val duelsWins = QuestsOG.duels.userManager.get(player.uniqueId)?.wins ?: 0
 
@@ -60,10 +73,10 @@ class HomesTwo : Quest {
         }
 
         return requirements.totalShards >= 100 * 9 &&
-                requirements.ticksPlayed / 20.0 / 60.0 / 60.0 >= 24 &&
-                requirements.totalCm / 100.0 >= 10000 &&
-                requirements.levels >= 50 &&
-                requirements.duelsWins >= 10
+            requirements.ticksPlayed / 20.0 / 60.0 / 60.0 >= 24 &&
+            requirements.totalCm / 100.0 >= 10000 &&
+            requirements.levels >= 50 &&
+            requirements.duelsWins >= 10
     }
 
     override suspend fun consumeQuestItems(player: Player): Boolean {
@@ -73,9 +86,7 @@ class HomesTwo : Quest {
             return false
         }
 
-        runOnMainThread {
-            player.level -= 100
-        }
+        runOnMainThread { player.level -= 100 }
 
         return true
     }
@@ -83,9 +94,7 @@ class HomesTwo : Quest {
     override fun reward(player: Player) {
         val homesTwoNode = PermissionNode.builder("essentials.sethome.multiple.homes-2").build()
 
-        QuestsOG.luckPerms.userManager.modifyUser(player.uniqueId) { user ->
-            user.data().add(homesTwoNode)
-        }
+        QuestsOG.luckPerms.userManager.modifyUser(player.uniqueId) { user -> user.data().add(homesTwoNode) }
     }
 
     override suspend fun getRequirements(player: Player): Array<Requirement>? {
@@ -98,7 +107,7 @@ class HomesTwo : Quest {
         return arrayOf(
             ProgressRequirement("Total Shards", requirements.totalShards, 100 * 9),
             ProgressRequirement("Ticks Played", requirements.ticksPlayed, 1728000),
-            ProgressRequirement("Total Cm Travelled", requirements.totalCm, 1000000)
+            ProgressRequirement("Total Cm Travelled", requirements.totalCm, 1000000),
         )
     }
-}
+}

src/main/kotlin/net/trueog/questsOG/quests/Quest.kt

@@ -6,12 +6,10 @@ import org.bukkit.entity.Player
 interface Quest {
     suspend fun isEligible(player: Player): Boolean?
 
-    /**
-     * @return True if successful
-     */
+    /** @return True if successful */
     suspend fun consumeQuestItems(player: Player): Boolean
 
     fun reward(player: Player)
 
     suspend fun getRequirements(player: Player): Array<Requirement>?
-}
+}