wip: denizen extension

buildSrc/src/main/kotlin/dependencies.kt

@@ -13,6 +13,10 @@ object acf {
     const val paper = "co.aikar:acf-paper:0.5.0-SNAPSHOT"
 }
 
+object denizenscript {
+    const val denizen = "com.denizenscript:denizen:1.2.3-SNAPSHOT"
+}
+
 object misc {
     const val bstats = "org.bstats:bstats-bukkit:1.8"
     const val annotations = "org.jetbrains:annotations:13.0"

mimic-bukkit/build.gradle.kts

@@ -36,6 +36,7 @@ repositories {
     flatDir { dir("libs") }
     // Uncomment if you want to get Heroes from maven repo
     //maven(url = "https://nexus.hc.to/content/repositories/pub_snapshots/")
+    maven(url = "https://repo.citizensnpcs.co")
 }
 
 dependencies {
@@ -55,6 +56,8 @@ dependencies {
     compileOnly(rpgplugins.mmoItems) { isTransitive = false }
     compileOnly(rpgplugins.heroes) { isTransitive = false }
 
+    compileOnly(denizenscript.denizen)
+
     // From libs/ directory
     compileOnly(":CustomItemsAPI")
     compileOnly(":QuantumRPG:5.10.2")

mimic-bukkit/src/main/kotlin/MimicPlugin.kt

@@ -22,6 +22,7 @@ package ru.endlesscode.mimic
 import co.aikar.commands.PaperCommandManager
 import org.bstats.bukkit.Metrics
 import org.bukkit.Bukkit
+import org.bukkit.event.server.ServerLoadEvent
 import org.bukkit.plugin.ServicePriority
 import org.bukkit.plugin.ServicePriority.*
 import org.bukkit.plugin.java.JavaPlugin
@@ -32,6 +33,7 @@ import ru.endlesscode.mimic.command.ClassSystemSubcommand
 import ru.endlesscode.mimic.command.ItemsSubcommand
 import ru.endlesscode.mimic.command.LevelSystemSubcommand
 import ru.endlesscode.mimic.command.MainCommand
+import ru.endlesscode.mimic.denizen.DenizenScriptBridge
 import ru.endlesscode.mimic.config.MimicConfig
 import ru.endlesscode.mimic.impl.battlelevels.BattleLevelsLevelSystem
 import ru.endlesscode.mimic.impl.customitems.CustomItemsRegistry
@@ -117,8 +119,14 @@ public class MimicPlugin : JavaPlugin() {
         pluginHooks("MMOItems", "net.Indyuce.mmoitems.MMOItems") {
             hookItems(::MmoItemsRegistry)
         }
+
+        pluginHooks("Denizen", "com.denizenscript.denizen.Denizen") {
+            DenizenScriptBridge.hook();
+        }
+
     }
 
+
     private fun pluginHooks(name: String, vararg requiredClasses: String, hooks: () -> Unit) {
         val pluginLoaded = Bukkit.getPluginManager().getPlugin(name) != null
         if (pluginLoaded && checkClassesLoaded(*requiredClasses)) {

mimic-bukkit/src/main/kotlin/denizen/DenizenScriptBridge.kt

@@ -0,0 +1,165 @@
+package ru.endlesscode.mimic.denizen
+
+import com.denizenscript.denizen.objects.PlayerTag
+import com.denizenscript.denizencore.objects.Mechanism
+import com.denizenscript.denizencore.objects.ObjectTag
+import com.denizenscript.denizencore.objects.core.ElementTag
+import com.denizenscript.denizencore.objects.core.ListTag
+import com.denizenscript.denizencore.objects.properties.Property
+import com.denizenscript.denizencore.objects.properties.PropertyParser
+import com.denizenscript.denizencore.tags.Attribute
+import com.sucy.skill.SkillAPI
+import org.bukkit.Bukkit
+import ru.endlesscode.mimic.classes.BukkitClassSystem
+import ru.endlesscode.mimic.classes.ClassSystem
+import ru.endlesscode.mimic.level.BukkitLevelSystem
+import ru.endlesscode.mimic.level.LevelSystem
+
+
+public class DenizenScriptBridge {
+
+    public companion object {
+
+        public fun hook() {
+            PropertyParser.registerProperty(MimicPlayerTagClassProperties::class.java, PlayerTag::class.java)
+        }
+    }
+
+    public class MimicPlayerTagClassProperties private constructor(
+            public var player: PlayerTag
+            ) : Property {
+
+        override fun getPropertyString(): String? {
+            return null
+        }
+
+        override fun getPropertyId(): String {
+            return "MimicPlayerClass"
+        }
+
+        override fun adjust(mechanism: Mechanism) {}
+
+        private fun classSystem(): ClassSystem? {
+            val provider = Bukkit.getServicesManager().getRegistration(BukkitClassSystem.Provider::class.java);
+            return provider?.provider?.getSystem(player.playerEntity)
+        }
+
+        private fun levelSystem(): LevelSystem {
+            val provider = Bukkit.getServicesManager().getRegistration(BukkitLevelSystem.Provider::class.java);
+            return provider!!.provider.getSystem(player.playerEntity)
+        }
+
+        override fun getAttribute(a: Attribute): String? {
+            if (a.startsWith("mimic")) {
+
+               val attribute = a.fulfill(1)
+
+                // <--[tag]
+                // @attribute <PlayerTag.mimic.has_class[classname]>
+                // @returns ElementTag(Boolean)
+                // @description
+                // Returns whether the player has specific class
+                // -->
+                if (attribute.startsWith("has_class")) {
+                    if (!attribute.hasParam()) {
+                        attribute.echoError("has_class requires a class name argument");
+                        return null;
+                    }
+                    return ElementTag(classSystem()!!.hasClass(attribute.param)).getAttribute(attribute.fulfill(1))
+                }
+
+                // <--[tag]
+                // @attribute <PlayerTag.mimic.primary_class>
+                // @returns ElementTag(String)
+                // @description
+                // Returns primary class
+                // -->
+                if (attribute.startsWith("primary_class")) {
+                    return ElementTag(classSystem()!!.primaryClass).getAttribute(attribute.fulfill(1));
+                }
+
+                // <--[tag]
+                // @attribute <PlayerTag.mimic.class_level[class_name]>
+                // @returns ElementTag(Int)
+                // @description
+                // Returns the player class level
+                // -->
+                if (attribute.startsWith("class_level")) {
+                    //todo level system supports getting only primary class level
+                    //if (!attribute.hasParam()) {
+                    //    attribute.echoError("has_class requires a class name argument");
+                    //    return null;
+                    //}
+                    return ElementTag(levelSystem().level).getAttribute(attribute.fulfill(1))
+                }
+
+                // <--[tag]
+                // @attribute <PlayerTag.mimic.give_exp[int]>
+                // @returns ElementTag(String)
+                // @description
+                // Returns level after exp were given
+                // -->
+                if (attribute.startsWith("class_give_exp")) {
+                    val levelSystem = levelSystem();
+                    levelSystem.giveExp(attribute.doubleParam)
+                    return ElementTag(levelSystem.level).getAttribute(attribute.fulfill(1));
+                }
+
+                // <--[tag]
+                // @attribute <PlayerTag.mimic.give_level[int]>
+                // @returns ElementTag(String)
+                // @description
+                // Returns level after exp were given
+                // -->
+                if (attribute.startsWith("give_level")) {
+                    val levelSystem = levelSystem();
+                    levelSystem.giveLevels(attribute.intParam)
+                    return ElementTag(levelSystem.level).getAttribute(attribute.fulfill(1));
+                }
+
+                // <--[tag]
+                // @attribute <PlayerTag.mimic.total_exp>
+                // @returns ElementTag(String)
+                // @description
+                // Returns players total exp
+                // -->
+                if (attribute.startsWith("total_exp")) {
+                    val levelSystem = levelSystem();
+                    return ElementTag(levelSystem.totalExp).getAttribute(attribute.fulfill(1));
+                }
+
+                // <--[tag]
+                // @attribute <PlayerTag.mimic.classes>
+                // @returns List(String)
+                // @description
+                // Returns list of player classes
+                // -->
+                if (attribute.startsWith("classes")) {
+                    val classSystem = classSystem()!!;
+                    return ListTag(classSystem.classes).getAttribute(attribute.fulfill(1));
+                }
+            }
+
+            return null
+        }
+
+        public companion object {
+            public fun describes(`object`: ObjectTag?): Boolean {
+                return `object` is PlayerTag
+            }
+
+            public fun getFrom(`object`: ObjectTag): MimicPlayerTagClassProperties? {
+                return if (!describes(`object`)) {
+                    null
+                } else {
+                    MimicPlayerTagClassProperties(`object` as PlayerTag)
+                }
+            }
+
+            public val handledTags: Array<String> = arrayOf(
+                    "mimic",
+            )
+            public val handledMechs: Array<String> = arrayOf<String>()
+        }
+    }
+}