diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..09549f6 --- /dev/null +++ b/pom.xml @@ -0,0 +1,127 @@ + + + 4.0.0 + + com.fivevl + skymines + 1.0-SNAPSHOT + jar + + SkyMines + + Skymines but kotlin + + 1.8 + UTF-8 + 1.6.10 + + + + + + org.apache.maven.plugins + maven-shade-plugin + 3.2.4 + + + package + + shade + + + false + + + + + + org.jetbrains.kotlin + kotlin-maven-plugin + ${kotlin.version} + + + compile + compile + + compile + + + + test-compile + test-compile + + test-compile + + + + + 1.8 + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.8.1 + + + compile + compile + + compile + + + + testCompile + test-compile + + testCompile + + + + + ${java.version} + ${java.version} + + + + + + src/main/resources + true + + + + + + + papermc-repo + https://papermc.io/repo/repository/maven-public/ + + + sonatype + https://oss.sonatype.org/content/groups/public/ + + + + + + io.papermc.paper + paper-api + 1.17.1-R0.1-SNAPSHOT + provided + + + org.jetbrains.kotlin + kotlin-stdlib-jdk8 + ${kotlin.version} + + + org.jetbrains.kotlin + kotlin-test-junit + ${kotlin.version} + test + + + diff --git a/src/main/java/com/fivevl/skymines/Compressors.kt b/src/main/java/com/fivevl/skymines/Compressors.kt new file mode 100644 index 0000000..b8ded6c --- /dev/null +++ b/src/main/java/com/fivevl/skymines/Compressors.kt @@ -0,0 +1,25 @@ +package com.fivevl.skymines + +import org.bukkit.Material +import org.bukkit.inventory.ItemStack + +enum class Compressors(val item: ItemStack, val compress: Items) { + STONE_COMPRESSOR(getCompressor("&7Stone"), Items.COMPRESSED_STONE), + COAL_COMPRESSOR(getCompressor("&8Coal"), Items.COMPRESSED_COAL), + GOLD_COMPRESSOR(getCompressor("&6Gold"), Items.COMPRESSED_GOLD), + IRON_COMPRESSOR(getCompressor("&7Iron"), Items.COMPRESSED_IRON), + DIAMOND_COMPRESSOR(getCompressor("&bDiamond"), Items.COMPRESSED_DIAMOND), + EMERALD_COMPRESSOR(getCompressor("&aEmerald"), Items.COMPRESSED_EMERALD), + REDSTONE_COMPRESSOR(getCompressor("&cRedstone"), Items.COMPRESSED_REDSTONE), + LAPIS_COMPRESSOR(getCompressor("&3Lapis"), Items.COMPRESSED_LAPIS), + ICE_COMPRESSOR(getCompressor("&bIce"), Items.COMPRESSED_ICE), + SNOW_COMPRESSOR(getCompressor("&fSnow"), Items.COMPRESSED_SNOW) +} +@Suppress("deprecation") +private fun getCompressor(name: String): ItemStack { + val item = ItemStack(Material.DISPENSER) + val meta = item.itemMeta + meta.setDisplayName(Utils.hex("$name Autocompressor")) + item.itemMeta = meta + return item +} \ No newline at end of file diff --git a/src/main/java/com/fivevl/skymines/Items.kt b/src/main/java/com/fivevl/skymines/Items.kt new file mode 100644 index 0000000..db27a7e --- /dev/null +++ b/src/main/java/com/fivevl/skymines/Items.kt @@ -0,0 +1,30 @@ +package com.fivevl.skymines + +import org.bukkit.Material +import org.bukkit.enchantments.Enchantment +import org.bukkit.inventory.ItemFlag +import org.bukkit.inventory.ItemStack + +enum class Items(val item: ItemStack) { + COMPRESSED_STONE(getCompressedItem(Material.STONE, "&7Compressed Stone")), + COMPRESSED_COAL(getCompressedItem(Material.COAL, "&8Compressed Coal")), + COMPRESSED_GOLD(getCompressedItem(Material.GOLD_INGOT, "&6Compressed Gold")), + COMPRESSED_IRON(getCompressedItem(Material.IRON_INGOT, "&7Compressed Iron")), + COMPRESSED_DIAMOND(getCompressedItem(Material.DIAMOND, "&bCompressed Diamond")), + COMPRESSED_EMERALD(getCompressedItem(Material.EMERALD, "&aCompressed Emerald")), + COMPRESSED_REDSTONE(getCompressedItem(Material.REDSTONE, "&cCompressed Redstone")), + COMPRESSED_LAPIS(getCompressedItem(Material.LAPIS_LAZULI, "&3Compressed Lapis")), + COMPRESSED_ICE(getCompressedItem(Material.PACKED_ICE, "&bCompressed Ice")), + COMPRESSED_SNOW(getCompressedItem(Material.SNOW_BLOCK, "&fCompressed Snow")) +} + +@Suppress("deprecation") +private fun getCompressedItem(mat: Material, name: String): ItemStack { + val item = ItemStack(mat) + val meta = item.itemMeta + meta.setDisplayName(Utils.hex(name)) + meta.addEnchant(Enchantment.DURABILITY, 1, true) + meta.addItemFlags(ItemFlag.HIDE_ENCHANTS) + item.itemMeta = meta + return item +} diff --git a/src/main/java/com/fivevl/skymines/Main.kt b/src/main/java/com/fivevl/skymines/Main.kt new file mode 100644 index 0000000..7f9a9f3 --- /dev/null +++ b/src/main/java/com/fivevl/skymines/Main.kt @@ -0,0 +1,125 @@ +package com.fivevl.skymines + +import com.fivevl.skymines.commands.CompressorCommand +import com.fivevl.skymines.commands.ResetMineCommand +import com.fivevl.skymines.commands.ScrollCommand +import com.fivevl.skymines.commands.SpawnCommand +import com.fivevl.skymines.listeners.* +import com.fivevl.skymines.tabcomplete.ResetMineTabComplete +import org.bukkit.Bukkit +import org.bukkit.Location +import org.bukkit.Material +import org.bukkit.World +import org.bukkit.configuration.ConfigurationSection +import org.bukkit.configuration.file.YamlConfiguration +import org.bukkit.plugin.java.JavaPlugin +import java.io.File +import java.io.IOException +import java.util.stream.Collectors + + +class Main : JavaPlugin() { + override fun onEnable() { + Utils.mainInstance = this + if (dataFolder.mkdir()) { + logger.info("Data folder created!") + } + createPlayerData() + registerMines() + registerCommands() + registerListeners() + } + + private fun registerCommands() { + getCommand("resetmine")?.setExecutor(ResetMineCommand()) + getCommand("resetmine")?.tabCompleter = ResetMineTabComplete() + getCommand("spawn")?.setExecutor(SpawnCommand()) + getCommand("compressor")?.setExecutor(CompressorCommand()) + getCommand("scroll")?.setExecutor(ScrollCommand()) + } + + private fun registerListeners() { + val plm = Bukkit.getPluginManager() + plm.registerEvents(MineListener(), this) + plm.registerEvents(PlayerJoinListener(), this) + plm.registerEvents(PlayerMoveListener(), this) + plm.registerEvents(CommandBlock(), this) + plm.registerEvents(ClickListener(), this) + } + + private fun createPlayerData() { + val file = File(dataFolder, "playerdata.yml") + try { + if (file.createNewFile()) { + logger.info("Created new playerdata.yml file.") + } + } catch (e: IOException) { + logger.info("Could not create new playerdata.yml file.") + e.printStackTrace() + } + } + + private fun registerMines() { + createMinesYaml() + val file = File(dataFolder, "mines.yml") + val yamlConfig = YamlConfiguration.loadConfiguration(file) + val minesList: List = + yamlConfig.getConfigurationSection("")?.getKeys(false)?.stream() + ?.map(yamlConfig::getConfigurationSection)?.collect(Collectors.toList()) as List + for (sect in minesList) { + if (!sect!!.name.equals("ExampleMine", ignoreCase = true)) { + val world: World? = sect.getString("World")?.let { Bukkit.getWorld(it) } + val corner1 = sect.getConfigurationSection("Corner1") + val corner2 = sect.getConfigurationSection("Corner2") + assert(corner1 != null) + val loc1 = Location(world, corner1!!.getInt("x").toDouble(), corner1.getInt("y").toDouble(), corner1.getInt("z").toDouble() + ) + assert(corner2 != null) + val loc2 = Location(world, corner2!!.getInt("x").toDouble(), corner2.getInt("y").toDouble(), corner2.getInt("z").toDouble() + ) + val mat1 = sect.getString("75PercentOfMine")?.let { Material.matchMaterial(it) } + val mat2 = sect.getString("25PercentOfMine")?.let { Material.matchMaterial(it) } + Utils.mines[sect.name] = Mine(loc1, loc2, mat1!!, mat2!!) + } + } + autoResetMines() + } + + private fun autoResetMines() { + val sched = Bukkit.getScheduler() + sched.scheduleSyncRepeatingTask(this, { + if (!Bukkit.getOnlinePlayers().isEmpty()) { + for (mine in Utils.mines.values) { + mine.resetMine() + } + } + }, 0, (15 * 20).toLong()) + } + + private fun createMinesYaml() { + val file = File(dataFolder, "mines.yml") + try { + if (file.createNewFile()) { + logger.info("Created new mines.yml file.") + val yamlConfig = YamlConfiguration.loadConfiguration(file) + val exampleMineSect = yamlConfig.createSection("ExampleMine") + exampleMineSect["World"] = "world" + val corner1Sect = exampleMineSect.createSection("Corner1") + corner1Sect["x"] = 0 + corner1Sect["y"] = 80 + corner1Sect["z"] = 0 + val corner2Sect = exampleMineSect.createSection("Corner2") + corner2Sect["x"] = 20 + corner2Sect["y"] = 100 + corner2Sect["z"] = 20 + exampleMineSect["75PercentOfMine"] = "STONE" + exampleMineSect["25PercentOfMine"] = "COBBLESTONE" + yamlConfig.save(file) + } + } catch (e: IOException) { + logger.severe("Could not create new mines.yml file.") + e.printStackTrace() + } + } + +} \ No newline at end of file diff --git a/src/main/java/com/fivevl/skymines/Mine.kt b/src/main/java/com/fivevl/skymines/Mine.kt new file mode 100644 index 0000000..3afa0dd --- /dev/null +++ b/src/main/java/com/fivevl/skymines/Mine.kt @@ -0,0 +1,31 @@ +package com.fivevl.skymines + +import org.bukkit.Bukkit +import org.bukkit.Location +import org.bukkit.Material +import java.util.* + + +class Mine(private var loc1: Location, private var loc2: Location, private var b75: Material, private var b25: Material) { + fun resetMine() { + val rand = Random() + for (x in loc1.blockX.coerceAtMost(loc2.blockX)..loc1.blockX.coerceAtLeast(loc2.blockX)) { + for (y in loc1.blockY.coerceAtMost(loc2.blockY)..loc1.blockY.coerceAtLeast(loc2.blockY)) { + for (z in loc1.blockZ.coerceAtMost(loc2.blockZ)..loc1.blockZ.coerceAtLeast(loc2.blockZ)) { + for (p in Bukkit.getOnlinePlayers()) { + val pLoc = p.location + if (pLoc.blockX == x && pLoc.blockY == y && pLoc.blockZ == z) { + p.teleport(pLoc.add(0.0, 1.0, 0.0)) + } + } + val block = rand.nextInt(100) + if (block < 75) { + Location(Bukkit.getWorld("world"), x.toDouble(), y.toDouble(), z.toDouble()).block.type = b75 + } else { + Location(Bukkit.getWorld("world"), x.toDouble(), y.toDouble(), z.toDouble()).block.type = b25 + } + } + } + } + } +} diff --git a/src/main/java/com/fivevl/skymines/Scrolls.kt b/src/main/java/com/fivevl/skymines/Scrolls.kt new file mode 100644 index 0000000..7710cc6 --- /dev/null +++ b/src/main/java/com/fivevl/skymines/Scrolls.kt @@ -0,0 +1,23 @@ +package com.fivevl.skymines + +import org.bukkit.Bukkit +import org.bukkit.Location +import org.bukkit.Material +import org.bukkit.enchantments.Enchantment +import org.bukkit.inventory.ItemFlag +import org.bukkit.inventory.ItemStack + +enum class Scrolls(val item: ItemStack, val location: Location) { + ICE_SCROLL(getScroll("Ice"), Location(Bukkit.getWorld("world"), -165.5, 82.0, -52.5, 0F, 0F)), + DESERT_SCROLL(getScroll("Desert"), Location(Bukkit.getWorld("world"), -256.5, 92.0, -78.5, 180F, 0F)) +} +@Suppress("deprecation") +fun getScroll(name: String): ItemStack { + val item = ItemStack(Material.PAPER) + val meta = item.itemMeta + meta.setDisplayName(Utils.hex("&bTravel Scroll - $name")) + meta.addEnchant(Enchantment.DURABILITY, 1, true) + meta.addItemFlags(ItemFlag.HIDE_ENCHANTS) + item.itemMeta = meta + return item +} \ No newline at end of file diff --git a/src/main/java/com/fivevl/skymines/Utils.kt b/src/main/java/com/fivevl/skymines/Utils.kt new file mode 100644 index 0000000..d5191e3 --- /dev/null +++ b/src/main/java/com/fivevl/skymines/Utils.kt @@ -0,0 +1,28 @@ +package com.fivevl.skymines + +import net.md_5.bungee.api.ChatColor +import org.bukkit.Bukkit +import org.bukkit.Location +import java.util.regex.Pattern + + +object Utils { + var mainInstance: Main? = null + var mines: HashMap = HashMap() + var spawn = Location(Bukkit.getWorld("world"), 0.5, 73.0, 0.5, 180F, 0F) + fun hex(s: String): String { + var s2 = s + val pattern = Pattern.compile("#[a-fA-F0-9]{6}") + var match = pattern.matcher(s) + while (match.find()) { + val color = s.substring(match.start(), match.end()) + s2 = s2.replace(color, ChatColor.of(color).toString() + "") + match = pattern.matcher(s2) + } + return ChatColor.translateAlternateColorCodes('&', s2) + } + + fun hasCooldown(time: Long): Boolean { + return time < System.currentTimeMillis() + } +} diff --git a/src/main/java/com/fivevl/skymines/commands/CompressorCommand.kt b/src/main/java/com/fivevl/skymines/commands/CompressorCommand.kt new file mode 100644 index 0000000..6cc04b7 --- /dev/null +++ b/src/main/java/com/fivevl/skymines/commands/CompressorCommand.kt @@ -0,0 +1,39 @@ +package com.fivevl.skymines.commands + +import com.fivevl.skymines.Compressors +import com.fivevl.skymines.Utils +import org.bukkit.command.Command +import org.bukkit.command.CommandExecutor +import org.bukkit.command.CommandSender +import org.bukkit.entity.Player +import java.util.StringJoiner + +class CompressorCommand : CommandExecutor { + override fun onCommand(sender: CommandSender, command: Command, label: String, args: Array): Boolean { + if (sender !is Player) { + sender.sendMessage(Utils.hex("&cYou can only run this command as a player!")) + return true + } + if (!sender.hasPermission("sm.bypass")) { + sender.sendMessage(Utils.hex("&cYou do not have permission to execute this command!")) + return true + } + if (args.size != 1) { + sender.sendMessage(Utils.hex("&cCorrect command usage: /compressor [compressor type]")) + return true + } + val comp: Compressors? + try { + comp = Compressors.valueOf("${args[0].uppercase()}_COMPRESSOR") + } catch (ex: IllegalArgumentException) { + val joiner = StringJoiner("\n") + for (c in Compressors.values()) { + joiner.add("&c" + c.name.substring(0, c.name.length - 11)) + } + sender.sendMessage(Utils.hex("&cThat is not a valid compressor! \n&cCorrect compressors: \n${joiner}")) + return true + } + sender.inventory.addItem(comp.item) + return true + } +} \ No newline at end of file diff --git a/src/main/java/com/fivevl/skymines/commands/ResetMineCommand.kt b/src/main/java/com/fivevl/skymines/commands/ResetMineCommand.kt new file mode 100644 index 0000000..b6d2285 --- /dev/null +++ b/src/main/java/com/fivevl/skymines/commands/ResetMineCommand.kt @@ -0,0 +1,45 @@ +package com.fivevl.skymines.commands + +import org.bukkit.command.Command +import org.bukkit.command.CommandExecutor +import org.bukkit.command.CommandSender +import org.bukkit.entity.Player +import com.fivevl.skymines.Utils +import java.util.* + + +class ResetMineCommand : CommandExecutor { + private val resetMineCooldown = HashMap() + override fun onCommand(sender: CommandSender, command: Command, label: String, args: Array): Boolean { + if (!sender.hasPermission("sm.mines.reset")) { + sender.sendMessage(Utils.hex("&cYou do not have permission to execute this command!")) + return true + } + if (sender is Player && resetMineCooldown.containsKey(sender) && resetMineCooldown[sender]?.let { + Utils.hasCooldown( + it + ) + } == true) { + sender.sendMessage(Utils.hex("&cThis command is on cooldown!")) + return true + } + val mineNames = StringJoiner(" ") + for (name in Utils.mines.keys) { + mineNames.add(name) + } + if (args.size != 1) { + sender.sendMessage(Utils.hex("&cCorrect command usage: /resetmine [mine] \n&cAll correct mines: $mineNames")) + return true + } + if (!Utils.mines.containsKey(args[0])) { + sender.sendMessage(Utils.hex("&cThat is not a correct mine! \n&cAll correct mines: $mineNames")) + return true + } + Utils.mines[args[0]]?.resetMine() + sender.sendMessage(Utils.hex("&aSuccessfully reset mine '" + args[0] + "'!")) + if (sender is Player && !sender.hasPermission("sm.mines.reset.bypass")) { + resetMineCooldown[sender] = System.currentTimeMillis() + (60 * 1000) + } + return true + } +} diff --git a/src/main/java/com/fivevl/skymines/commands/ScrollCommand.kt b/src/main/java/com/fivevl/skymines/commands/ScrollCommand.kt new file mode 100644 index 0000000..b04f230 --- /dev/null +++ b/src/main/java/com/fivevl/skymines/commands/ScrollCommand.kt @@ -0,0 +1,53 @@ +package com.fivevl.skymines.commands + +import com.fivevl.skymines.Scrolls +import com.fivevl.skymines.Utils +import org.bukkit.Bukkit +import org.bukkit.command.Command +import org.bukkit.command.CommandExecutor +import org.bukkit.command.CommandSender +import java.util.StringJoiner + +class ScrollCommand : CommandExecutor { + override fun onCommand(sender: CommandSender, command: Command, label: String, args: Array): Boolean { + if (!sender.hasPermission("sm.givescroll")) { + sender.sendMessage(Utils.hex("&cYou do not have permission to execute this command!")) + return true + } + if (args.size != 3) { + sender.sendMessage(Utils.hex("&cCorrect command usage: /scroll [player] [scroll] [amount]")) + return true + } + val gp = Bukkit.getPlayer(args[0]) + if (gp == null) { + sender.sendMessage(Utils.hex("&cThat is not a correct player!")) + return true + } + var scroll: Scrolls? = null + for (name in Scrolls.values()) { + if (args[1].uppercase() == name.toString().substring(0, name.toString().length - 7)) { + scroll = name + break + } + } + if (scroll == null) { + val join = StringJoiner("\n") + for (name in Scrolls.values()) { + join.add(name.toString().substring(0, name.toString().length - 7)) + } + sender.sendMessage(Utils.hex("&cThat is not a correct scroll! Correct scrolls:\n$join")) + return true + } + val amount: Int + try { + amount = args[2].toInt() + } catch (e: NumberFormatException) { + sender.sendMessage(Utils.hex("&cThat is not a correct amount!")) + return true + } + val item = scroll.item + item.amount = amount + gp.inventory.addItem(item) + return true + } +} \ No newline at end of file diff --git a/src/main/java/com/fivevl/skymines/commands/SpawnCommand.kt b/src/main/java/com/fivevl/skymines/commands/SpawnCommand.kt new file mode 100644 index 0000000..d5b711d --- /dev/null +++ b/src/main/java/com/fivevl/skymines/commands/SpawnCommand.kt @@ -0,0 +1,24 @@ +package com.fivevl.skymines.commands + +import org.bukkit.command.Command +import org.bukkit.command.CommandExecutor +import org.bukkit.command.CommandSender +import org.bukkit.entity.Player +import com.fivevl.skymines.Utils + + +class SpawnCommand : CommandExecutor { + override fun onCommand(sender: CommandSender, command: Command, label: String, args: Array): Boolean { + if (sender !is Player) { + sender.sendMessage(Utils.hex("&cOnly players may execute this command!")) + return true + } + if (!sender.hasPermission("sm.spawn")) { + sender.sendMessage(Utils.hex("&cYou do not have permission to execute this command!")) + return true + } + sender.teleport(Utils.spawn) + sender.sendMessage(Utils.hex("&aYou have been teleported to spawn!")) + return true + } +} diff --git a/src/main/java/com/fivevl/skymines/listeners/ClickListener.kt b/src/main/java/com/fivevl/skymines/listeners/ClickListener.kt new file mode 100644 index 0000000..0e8490a --- /dev/null +++ b/src/main/java/com/fivevl/skymines/listeners/ClickListener.kt @@ -0,0 +1,24 @@ +package com.fivevl.skymines.listeners + +import com.fivevl.skymines.Scrolls +import org.bukkit.event.EventHandler +import org.bukkit.event.Listener +import org.bukkit.event.player.PlayerInteractEvent +import org.bukkit.inventory.EquipmentSlot + +class ClickListener : Listener { + @EventHandler + fun onClick(e: PlayerInteractEvent) { + if (e.hand != EquipmentSlot.HAND) return + val p = e.player + for (scroll in Scrolls.values()) { + if (p.inventory.itemInMainHand.isSimilar(scroll.item)) { + p.teleport(scroll.location) + val new = scroll.item + new.amount = p.inventory.itemInMainHand.amount - 1 + p.inventory.setItemInMainHand(new) + break + } + } + } +} \ No newline at end of file diff --git a/src/main/java/com/fivevl/skymines/listeners/CommandBlock.kt b/src/main/java/com/fivevl/skymines/listeners/CommandBlock.kt new file mode 100644 index 0000000..633548a --- /dev/null +++ b/src/main/java/com/fivevl/skymines/listeners/CommandBlock.kt @@ -0,0 +1,17 @@ +package com.fivevl.skymines.listeners + +import org.bukkit.event.EventHandler +import org.bukkit.event.Listener +import org.bukkit.event.player.PlayerCommandPreprocessEvent + +class CommandBlock : Listener { + @EventHandler + fun onBlockedCommand(e: PlayerCommandPreprocessEvent) { + val cmds = arrayOf("/pl", "/bukkit:pl", "/minecraft:me", "/me") + for (s in cmds) { + if (e.message.startsWith(s)) { + e.isCancelled = true + } + } + } +} \ No newline at end of file diff --git a/src/main/java/com/fivevl/skymines/listeners/MineListener.kt b/src/main/java/com/fivevl/skymines/listeners/MineListener.kt new file mode 100644 index 0000000..43b8d9e --- /dev/null +++ b/src/main/java/com/fivevl/skymines/listeners/MineListener.kt @@ -0,0 +1,155 @@ +package com.fivevl.skymines.listeners + +import com.fivevl.skymines.Compressors +import org.bukkit.Material +import org.bukkit.enchantments.Enchantment +import org.bukkit.entity.Player +import org.bukkit.event.EventHandler +import org.bukkit.event.Listener +import org.bukkit.event.block.BlockBreakEvent +import org.bukkit.inventory.ItemStack +import com.fivevl.skymines.Utils +import java.util.* +import kotlin.math.pow +import kotlin.math.roundToInt + + +class MineListener : Listener { + @EventHandler + fun onMine(e: BlockBreakEvent) { + val p = e.player + if (p.inventory.firstEmpty() == -1) { + p.sendMessage(Utils.hex("&cYour inventory is full!")) + e.isCancelled = true + return + } + val blockType = e.block.type + var cancel = false + when (p.inventory.itemInMainHand.type) { + Material.WOODEN_PICKAXE -> { + when (blockType) { + Material.STONE, Material.COBBLESTONE, Material.COAL_ORE, Material.COAL_BLOCK -> {} + else -> cancel = true + } + } + Material.STONE_PICKAXE -> { + when (blockType) { + Material.STONE, Material.COBBLESTONE, Material.COAL_ORE, Material.COAL_BLOCK, Material.GOLD_ORE, Material.GOLD_BLOCK -> {} + else -> cancel = true + } + } + Material.GOLDEN_PICKAXE -> { + when (blockType) { + Material.STONE, Material.COBBLESTONE, Material.COAL_ORE, Material.COAL_BLOCK, Material.GOLD_ORE, Material.GOLD_BLOCK, Material.IRON_ORE, Material.IRON_BLOCK -> {} + else -> cancel = true + } + } + Material.IRON_PICKAXE -> { + when (blockType) { + Material.STONE, Material.COBBLESTONE, Material.COAL_ORE, Material.COAL_BLOCK, Material.GOLD_ORE, Material.GOLD_BLOCK, Material.IRON_ORE, Material.IRON_BLOCK, Material.DIAMOND_ORE, Material.DIAMOND_BLOCK -> {} + else -> cancel = true + } + } + Material.DIAMOND_PICKAXE -> { + when (blockType) { + Material.STONE, Material.COBBLESTONE, Material.COAL_ORE, Material.COAL_BLOCK, Material.GOLD_ORE, Material.GOLD_BLOCK, Material.IRON_ORE, Material.IRON_BLOCK, Material.DIAMOND_ORE, Material.DIAMOND_BLOCK, Material.EMERALD_ORE, Material.EMERALD_BLOCK, Material.REDSTONE_ORE, Material.REDSTONE_BLOCK, Material.LAPIS_ORE, Material.LAPIS_BLOCK -> {} + else -> cancel = true + } + } + Material.NETHERITE_PICKAXE -> { + cancel = blockType == Material.SNOW_BLOCK + } + Material.WOODEN_SHOVEL -> { + cancel = blockType != Material.SNOW_BLOCK + } + else -> cancel = true + } + if (cancel && !p.hasPermission("sm.bypass")) { + e.isCancelled = true + return + } + if (!cancel) { + calculateItems(p, blockType) + } + } + + private fun calculateItems(p: Player, inBlock: Material) { + var block = inBlock + val hand = p.inventory.itemInMainHand + var amount = 1.0 + val compressor: Compressors + if (hand.containsEnchantment(Enchantment.LOOT_BONUS_BLOCKS)) { + val level = hand.getEnchantmentLevel(Enchantment.LOOT_BONUS_BLOCKS) + amount *= level.toDouble().pow(1.01) + val rand = Random() + amount = if (rand.nextInt(100) < 50) { + amount + 0.5 + } else { + amount - 0.5 + } + } + when (block) { + Material.STONE -> { + compressor = Compressors.STONE_COMPRESSOR + } + Material.COAL_ORE -> { + block = Material.COAL + compressor = Compressors.COAL_COMPRESSOR + } + Material.GOLD_ORE -> { + block = Material.RAW_GOLD + compressor = Compressors.GOLD_COMPRESSOR + } + Material.IRON_ORE -> { + block = Material.RAW_IRON + compressor = Compressors.IRON_COMPRESSOR + } + Material.DIAMOND_ORE -> { + block = Material.DIAMOND + compressor = Compressors.DIAMOND_COMPRESSOR + } + Material.EMERALD_ORE -> { + block = Material.EMERALD + compressor = Compressors.EMERALD_COMPRESSOR + } + Material.REDSTONE_ORE -> { + block = Material.REDSTONE + amount *= 2.0 + compressor = Compressors.REDSTONE_COMPRESSOR + } + Material.LAPIS_ORE -> { + block = Material.LAPIS_LAZULI + amount *= 2.0 + compressor = Compressors.LAPIS_COMPRESSOR + } + Material.BLUE_ICE -> { + compressor = Compressors.ICE_COMPRESSOR + } + Material.SNOW_BLOCK -> { + compressor = Compressors.SNOW_COMPRESSOR + } + else -> { + val str = block.toString() + if (str.endsWith("_BLOCK") || str == "STONE" || str == "COBBLESTONE") { + if (str == "GRASS_BLOCK") return + p.inventory.addItem(ItemStack(block, 1)) + return + } else return + } + } + getCompressedItem(p, compressor, block, amount) + } + + private fun getCompressedItem(p: Player, comp: Compressors?, block: Material, amount: Double) { + p.inventory.addItem(ItemStack(block, amount.roundToInt())) + if (comp == null) return + if (p.inventory.contains(block) && p.inventory.contains(comp.item)) { + for (i in p.inventory.contents) { + if (i != null && i.amount >= 64 && i.type == block && !i.itemMeta.hasEnchants()) { + p.inventory.remove(ItemStack(block, 64)) + p.inventory.addItem(comp.compress.item) + } + } + } + } +} diff --git a/src/main/java/com/fivevl/skymines/listeners/PlayerJoinListener.kt b/src/main/java/com/fivevl/skymines/listeners/PlayerJoinListener.kt new file mode 100644 index 0000000..8cb048f --- /dev/null +++ b/src/main/java/com/fivevl/skymines/listeners/PlayerJoinListener.kt @@ -0,0 +1,45 @@ +package com.fivevl.skymines.listeners + +import org.bukkit.event.EventHandler +import org.bukkit.event.Listener +import org.bukkit.event.player.PlayerJoinEvent +import com.fivevl.skymines.Utils +import org.bukkit.Bukkit +import org.bukkit.Material +import org.bukkit.configuration.file.YamlConfiguration +import org.bukkit.event.player.PlayerQuitEvent +import org.bukkit.inventory.ItemFlag +import org.bukkit.inventory.ItemStack +import java.io.File + + +class PlayerJoinListener : Listener { + @EventHandler + @Suppress("deprecation") + fun onJoin(e: PlayerJoinEvent) { + e.player.teleport(Utils.spawn) + val file = File(Utils.mainInstance?.dataFolder, "playerdata.yml") + val config = YamlConfiguration.loadConfiguration(file) + if (config.getConfigurationSection(e.player.uniqueId.toString()) == null) { + config.createSection(e.player.uniqueId.toString()) + e.player.inventory.addItem(ItemStack(Material.COOKED_BEEF, 16), getPick()) + config.save(file) + Bukkit.broadcastMessage(Utils.hex("&eWelcome ${e.player.name} to the server!")) + } + e.joinMessage(null) + } + + private fun getPick(): ItemStack { + val item = ItemStack(Material.WOODEN_PICKAXE) + val meta = item.itemMeta + meta.isUnbreakable = true + meta.addItemFlags(ItemFlag.HIDE_UNBREAKABLE) + item.itemMeta = meta + return item + } + + @EventHandler + fun onLeave(e: PlayerQuitEvent) { + e.quitMessage(null) + } +} diff --git a/src/main/java/com/fivevl/skymines/listeners/PlayerMoveListener.kt b/src/main/java/com/fivevl/skymines/listeners/PlayerMoveListener.kt new file mode 100644 index 0000000..f37f10f --- /dev/null +++ b/src/main/java/com/fivevl/skymines/listeners/PlayerMoveListener.kt @@ -0,0 +1,17 @@ +package com.fivevl.skymines.listeners + +import org.bukkit.event.EventHandler +import org.bukkit.event.Listener +import org.bukkit.event.player.PlayerMoveEvent +import com.fivevl.skymines.Utils + + +class PlayerMoveListener : Listener { + @EventHandler + fun onMove(e: PlayerMoveEvent) { + val p = e.player + if (p.location.y <= 0) { + p.teleport(Utils.spawn) + } + } +} diff --git a/src/main/java/com/fivevl/skymines/tabcomplete/ResetMineTabComplete.kt b/src/main/java/com/fivevl/skymines/tabcomplete/ResetMineTabComplete.kt new file mode 100644 index 0000000..811685e --- /dev/null +++ b/src/main/java/com/fivevl/skymines/tabcomplete/ResetMineTabComplete.kt @@ -0,0 +1,19 @@ +package com.fivevl.skymines.tabcomplete + +import org.bukkit.command.Command +import org.bukkit.command.CommandSender +import org.bukkit.command.TabCompleter +import com.fivevl.skymines.Utils + + +class ResetMineTabComplete : TabCompleter { + override fun onTabComplete(sender: CommandSender, command: Command, alias: String, args: Array): List { + val list = ArrayList() + if (sender.hasPermission("sm.mines.reset")) { + for (mines in Utils.mines.keys) { + list.add(mines) + } + } + return list + } +} diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml new file mode 100644 index 0000000..2f9607d --- /dev/null +++ b/src/main/resources/plugin.yml @@ -0,0 +1,15 @@ +name: SkyMines +version: '${project.version}' +main: com.fivevl.skymines.Main +api-version: 1.17 +authors: [ 5vl ] +description: Skymines plugin made by 5vl. +commands: + resetmine: + description: Reset a mine. + spawn: + description: Go to spawn. + compressor: + description: Get compressor. + scroll: + description: Get a scroll. \ No newline at end of file