init & test Version

2022-01-31 21:54:03 +08:00
commit d8f8f83ea5
11 changed files with 587 additions and 0 deletions
@@ -0,0 +1,5 @@
+package cc.maxmc.fwc
+
+import taboolib.platform.BukkitPlugin
+
+object FireworkCounter: BukkitPlugin()
@@ -0,0 +1,87 @@
+package cc.maxmc.fwc.listener
+
+import cc.maxmc.fwc.utils.Calculator
+import org.bukkit.FireworkEffect.Type.*
+import org.bukkit.Location
+import org.bukkit.Material
+import org.bukkit.entity.Player
+import org.bukkit.event.block.BlockBreakEvent
+import org.bukkit.event.block.BlockPlaceEvent
+import org.bukkit.event.entity.ExplosionPrimeEvent
+import org.bukkit.event.entity.FireworkExplodeEvent
+import org.bukkit.event.player.PlayerInteractEvent
+import taboolib.common.platform.event.SubscribeEvent
+
+object FireworkListener {
+    val breakCache = ArrayList<Location>(10000000)
+
+    @SubscribeEvent
+    fun onFirework(e: FireworkExplodeEvent) {
+        val shooter = e.entity.shooter
+        if (shooter !is Player) return
+        val fireworkData = e.entity.fireworkMeta
+        shooter.sendMessage("§b|")
+        shooter.sendMessage("§b|")
+        if (fireworkData.effectsSize == 0) {
+            shooter.sendMessage("§b| §7效果: 无")
+        } else {
+            shooter.sendMessage("§b| §7效果: ")
+            fireworkData.effects.forEach {
+                val typeName = when (it.type) {
+                    BALL -> "球状"
+                    BALL_LARGE -> "大型球状(火焰弹)"
+                    STAR -> "星型(金粒)"
+                    BURST -> "爆裂型爆炸(羽毛)"
+                    CREEPER -> "苦力怕(头颅)"
+                }
+                shooter.sendMessage("§b|  - §7种类: §b${typeName}")
+                if (it.hasTrail()) shooter.sendMessage("§b|    §7轨迹(钻石)")
+                if (it.hasFlicker()) shooter.sendMessage("§b|    §7闪烁(荧石粉)")
+            }
+        }
+        shooter.sendMessage("§b|   ")
+        shooter.sendMessage("§b| §7高度: §b${fireworkData.power}")
+        shooter.sendMessage("§6| §7花火点: §6${Calculator.calculateScore(e.entity.fireworkMeta)}")
+        shooter.sendMessage("§b|")
+        shooter.sendMessage("§b|")
+    }
+
+    @SubscribeEvent
+    fun onPlace(e: BlockPlaceEvent) {
+        if (e.blockPlaced.type == Material.TNT) {
+            e.player.sendMessage("§e| §7抱歉, 不能这么干呢.")
+            e.isCancelled = true
+        }
+    }
+
+    @SubscribeEvent
+    fun onInteract(e: PlayerInteractEvent) {
+        if (e.item?.type == Material.END_CRYSTAL) {
+            e.player.sendMessage("§e| §7抱歉, 不能这么干呢.")
+            e.isCancelled = true
+        }
+    }
+
+    @SubscribeEvent
+    fun onExplode(e: ExplosionPrimeEvent) {
+        e.isCancelled = true
+    }
+
+    @SubscribeEvent
+    fun onPlacePlayer(e: BlockPlaceEvent) {
+        if (e.player.isOp) return
+        breakCache.add(e.block.location)
+    }
+
+    @SubscribeEvent
+    fun onDestroyBlock(e: BlockBreakEvent) {
+        if (e.player.isOp) return
+        if (breakCache.contains(e.block.location)) {
+            breakCache.remove(e.block.location)
+            return
+        }
+        e.isCancelled = true
+        e.player.sendMessage("§e| §7抱歉, 不能这么干呢.")
+    }
+
+}
@@ -0,0 +1,168 @@
+package cc.maxmc.fwc.utils
+
+import org.bukkit.Bukkit
+import org.bukkit.FireworkEffect
+import org.bukkit.FireworkEffect.Type.*
+import org.bukkit.inventory.meta.FireworkMeta
+import java.math.BigDecimal
+import java.math.BigInteger
+import java.math.RoundingMode
+
+
+object Calculator {
+    fun calculateScore(meta: FireworkMeta): Int {
+        if (meta.effectsSize == 0) return calculatePower(5, meta.power)
+        val productScore = meta.effects.map { calculateEffect(it) }
+            .toCollection(ArrayList())
+            .let {
+                val prod = product(it)
+                val avg = bigRoot(prod, meta.effectsSize, 8, RoundingMode.HALF_UP.ordinal)
+                return@let avg.toInt()
+            }
+            .let { it * meta.effectsSize }
+            .let { it + 5 }
+            .toInt()
+
+        return calculatePower(productScore, meta.power)
+    }
+
+    private fun calculateEffect(effect: FireworkEffect): Int {
+        var result = 0
+        if (effect.hasFlicker()) result += 3
+        if (effect.hasTrail()) result += 50
+        result += when (effect.type) {
+            BALL -> 2
+            BALL_LARGE -> 16
+            STAR -> 5
+            BURST -> 8
+            CREEPER -> 200
+        }
+        return result
+    }
+
+    private fun calculatePower(score: Int, level: Int) = (score * ((level * 0.1) + 1)).toInt()
+
+    private fun product(numbers: List<Int>): BigDecimal {
+        var result = BigDecimal(1)
+        numbers.forEach { result = result.multiply(BigDecimal(it)) }
+        return result
+    }
+
+    /**
+     * BigDecimal开n次方根。
+     * 转载于：https://www.xuebuyuan.com/1863340.html
+     * @param number 被开方数
+     * @param n n次方根
+     * @param scale 精度
+     * @param roundingMode 舍入规则
+     * @return 结果
+     */
+    fun bigRoot(number: BigDecimal, n: Int, scale: Int, roundingMode: Int): BigDecimal {
+        var number = number
+        var negate = false
+        if (n < 0) throw ArithmeticException()
+        if (number.compareTo(BigDecimal.ZERO) < 0) {
+            if (n % 2 == 0) throw ArithmeticException() else {
+                number = number.negate()
+                negate = true
+            }
+        }
+        var root: BigDecimal
+        if (n == 0) root = BigDecimal.ONE else if (n == 1) root = number else {
+            val N = BigInteger.valueOf(n.toLong())
+            val N2 = BigInteger.TEN.pow(n)
+            val N3 = BigInteger.TEN.pow(n - 1)
+            val NINE = BigInteger.valueOf(9)
+            val C = arrayOfNulls<BigInteger>(n + 1)
+            for (i in 0..n) {
+                C[i] = combination(n, i)
+            }
+            val integer = number.toBigInteger()
+            var strInt = integer.toString()
+            var lenInt = strInt.length
+            run {
+                var i = lenInt % n
+                while (i < n && i > 0) {
+                    strInt = "0$strInt"
+                    i++
+                }
+            }
+            lenInt = (lenInt + n - 1) / n * n
+            var fraction = number.subtract(number.setScale(0, BigDecimal.ROUND_DOWN))
+            val lenFrac = (fraction.scale() + n - 1) / n * n
+            fraction = fraction.movePointRight(lenFrac)
+            var strFrac = fraction.toPlainString()
+            for (i in strFrac.length until lenFrac) strFrac = "0$strFrac"
+            var res = BigInteger.ZERO
+            var rem = BigInteger.ZERO
+            for (i in 0 until lenInt / n) {
+                rem = rem.multiply(N2)
+                var temp = BigInteger(strInt.substring(i * n, i * n + n))
+                rem = rem.add(temp)
+                var j: BigInteger
+                j =
+                    if (res.compareTo(BigInteger.ZERO) != 0) rem.divide(res.pow(n - 1).multiply(N)
+                        .multiply(N3)) else NINE
+                var test = BigInteger.ZERO
+                temp = res.multiply(BigInteger.TEN)
+                while (j.compareTo(BigInteger.ZERO) >= 0) {
+                    //test = res.multiply(BigInteger.TEN);
+                    //test = ((test.add(j)).pow(n)).subtract(test.pow(n));
+                    test = BigInteger.ZERO
+                    if (j.compareTo(BigInteger.ZERO) > 0) for (k in 1..n) test =
+                        test.add(j.pow(k).multiply(C[k]).multiply(temp.pow(n - k)))
+                    if (test.compareTo(rem) <= 0) break
+                    j = j.subtract(BigInteger.ONE)
+                }
+                rem = rem.subtract(test)
+                res = res.multiply(BigInteger.TEN)
+                res = res.add(j)
+            }
+            for (i in 0..scale) {
+                rem = rem.multiply(N2)
+                if (i < lenFrac / n) {
+                    val temp = BigInteger(strFrac.substring(i * n, i * n + n))
+                    rem = rem.add(temp)
+                }
+                var j: BigInteger
+                j = if (res.compareTo(BigInteger.ZERO) != 0) {
+                    rem.divide(res.pow(n - 1).multiply(N).multiply(N3))
+                } else NINE
+                var test = BigInteger.ZERO
+                val temp = res.multiply(BigInteger.TEN)
+                while (j.compareTo(BigInteger.ZERO) >= 0) {
+                    //test = res.multiply(BigInteger.TEN);
+                    //test = ((test.add(j)).pow(n)).subtract(test.pow(n));
+                    test = BigInteger.ZERO
+                    if (j.compareTo(BigInteger.ZERO) > 0) for (k in 1..n) test =
+                        test.add(j.pow(k).multiply(C[k]).multiply(temp.pow(n - k)))
+                    if (test.compareTo(rem) <= 0) break
+                    j = j.subtract(BigInteger.ONE)
+                }
+                rem = rem.subtract(test)
+                res = res.multiply(BigInteger.TEN)
+                res = res.add(j)
+            }
+            root = BigDecimal(res).movePointLeft(scale + 1)
+            if (negate) root = root.negate()
+        }
+        return root.setScale(scale, roundingMode)
+    }
+
+    private fun combination(n: Int, k: Int): BigInteger {
+        if (k > n || n < 0 || k < 0) return BigInteger.ZERO
+        if (k > n / 2) return combination(n, n - k)
+        var N1 = BigInteger.ONE
+        var N2 = BigInteger.ONE
+        var N = BigInteger.valueOf(n.toLong())
+        var K = BigInteger.valueOf(k.toLong())
+        for (i in 0 until k) {
+            N1 = N1.multiply(N)
+            N2 = N2.multiply(K)
+            N = N.subtract(BigInteger.ONE)
+            K = K.subtract(BigInteger.ONE)
+        }
+        return N1.divide(N2)
+    }
+
+}