Mimic/mimic-bukkit/src/main/kotlin/denizen/DenizenScriptBridge.kt at b73f0a4080e662dff884df398613e4db9e2b2db6 · EndlessCodeGroup/Mimic · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
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>()
        }
    }
}