Allow basic items to be registered

adrwa · adrwa · commit dc0964d14a91 · 2021-08-22T19:50:39.000+01:00
diff --git a/src/main/kotlin/org/sandboxpowered/fabric/api/PolyglotRecipeManager.kt b/src/main/kotlin/org/sandboxpowered/fabric/api/PolyglotRecipeManager.kt
@@ -8,7 +8,7 @@ import net.minecraft.util.registry.Registry
 import org.graalvm.polyglot.HostAccess.Export
 import org.graalvm.polyglot.Value
 import org.sandboxpowered.fabric.Main
-import org.sandboxpowered.fabric.util.getMemberValue
+import org.sandboxpowered.fabric.util.getMemberValueStr
 import org.sandboxpowered.fabric.util.removeIf
 import org.sandboxpowered.fabric.util.toJSON
 import java.util.function.BiPredicate
@@ -55,10 +55,10 @@ class PolyglotRecipeManager(private val map: MutableMap<Identifier, JsonElement>
 
         var predicate: BiPredicate<Identifier, JsonElement>? = null
 
-        val id = value.getMemberValue("id")
-        val output = value.getMemberValue("output")
-        val domain = value.getMemberValue("domain")
-        val type = value.getMemberValue("type")
+        val id = value.getMemberValueStr("id")
+        val output = value.getMemberValueStr("output")
+        val domain = value.getMemberValueStr("domain")
+        val type = value.getMemberValueStr("type")
 
         if (id != null) {
             val idPredicate = BiPredicate<Identifier, JsonElement> { identifier, _ -> identifier.toString() == id }
diff --git a/src/main/kotlin/org/sandboxpowered/fabric/api/SandboxResourcePolyglotContext.kt b/src/main/kotlin/org/sandboxpowered/fabric/api/SandboxResourcePolyglotContext.kt
@@ -23,7 +23,7 @@ class SandboxResourcePolyglotContext(private val resource: String, private val s
     @Export
     fun emit(event: String, vararg args: Any) {
         if (event.contains(':')) scriptLoader.emitEventToAll(event, *args)
-        else scriptLoader.emitEventTo(resource, event, *args)
+        else scriptLoader.emitEventTo(resource, event, args = args)
     }
 
     @Export
diff --git a/src/main/kotlin/org/sandboxpowered/fabric/api/item/PolyglotGlobalItemManager.kt b/src/main/kotlin/org/sandboxpowered/fabric/api/item/PolyglotGlobalItemManager.kt
@@ -0,0 +1,51 @@
+package org.sandboxpowered.fabric.api.item
+
+import com.google.common.collect.ImmutableMap
+import net.minecraft.item.Item
+import net.minecraft.util.Identifier
+import net.minecraft.util.Rarity
+import net.minecraft.util.registry.Registry
+import org.graalvm.polyglot.Value
+import org.sandboxpowered.fabric.impl.item.PolyglotItem
+import org.sandboxpowered.fabric.util.getMemberValue
+import org.sandboxpowered.fabric.util.getMemberValueInt
+import org.sandboxpowered.fabric.util.getMemberValueStr
+import org.sandboxpowered.fabric.util.set
+
+class PolyglotGlobalItemManager {
+    private val archetypeMap: Map<String, (Value) -> Item>
+
+    init {
+        val builder = ImmutableMap.builder<String, (Value) -> Item>()
+
+        builder["item"] = { PolyglotItem(itemPropertiesToSettings(it), it) }
+
+        archetypeMap = builder.build()
+    }
+
+    private fun itemPropertiesToSettings(value: Value): Item.Settings {
+        val settings = Item.Settings()
+        if (!value.hasMember("properties")) return settings
+        val properties = value.getMember("properties")
+        properties.getMemberValueInt("maxDamage")?.let(settings::maxDamage)
+        properties.getMemberValueInt("maxCount")?.let(settings::maxCount)
+        properties.getMemberValueStr("rarity")?.let {
+            settings.rarity(stringToRarity(it))
+        }
+        return settings
+    }
+
+    private fun stringToRarity(rarity: String): Rarity = when (rarity) {
+        "uncommon" -> Rarity.UNCOMMON
+        "rare" -> Rarity.RARE
+        "epic" -> Rarity.EPIC
+        else -> Rarity.COMMON
+    }
+
+    fun addItem(identifier: Identifier, value: Value) {
+        val archetype = value.getMemberValue("archetype", "item")
+        if (archetype !in archetypeMap) throw UnsupportedOperationException("Unknown item archetype [$archetype]")
+        val item = archetypeMap[archetype]!!(value)
+        Registry.register(Registry.ITEM, identifier, item)
+    }
+}
diff --git a/src/main/kotlin/org/sandboxpowered/fabric/api/item/PolyglotItemManager.kt b/src/main/kotlin/org/sandboxpowered/fabric/api/item/PolyglotItemManager.kt
@@ -0,0 +1,13 @@
+package org.sandboxpowered.fabric.api.item
+
+import net.minecraft.util.Identifier
+import org.graalvm.polyglot.HostAccess.Export
+import org.graalvm.polyglot.Value
+
+class PolyglotItemManager(private val domain: String, private val global: PolyglotGlobalItemManager) {
+    @Export
+    fun add(id: String, value: Value) {
+        if (!value.hasMembers()) throw UnsupportedOperationException("Unsupported value for item registration")
+        global.addItem(Identifier(domain, id), value)
+    }
+}
diff --git a/src/main/kotlin/org/sandboxpowered/fabric/impl/item/PolyglotItem.kt b/src/main/kotlin/org/sandboxpowered/fabric/impl/item/PolyglotItem.kt
@@ -0,0 +1,8 @@
+package org.sandboxpowered.fabric.impl.item
+
+import net.minecraft.item.Item
+import org.graalvm.polyglot.Value
+
+class PolyglotItem(settings: Settings, value: Value) : Item(settings) {
+
+}
diff --git a/src/main/kotlin/org/sandboxpowered/fabric/loading/SandboxLoader.kt b/src/main/kotlin/org/sandboxpowered/fabric/loading/SandboxLoader.kt
@@ -87,6 +87,10 @@ class SandboxLoader {
 
         log.info("Loaded ${addons.size} resources")
 
+        resourceContent.keys.forEach {
+            polyglotLoader.emitEventTo(it, "items", false, polyglotLoader.getItemManager(it))
+        }
+
         if (side == Side.SERVER) {
             val json = JsonObject()
 
diff --git a/src/main/kotlin/org/sandboxpowered/fabric/scripting/PolyglotScriptLoader.kt b/src/main/kotlin/org/sandboxpowered/fabric/scripting/PolyglotScriptLoader.kt
@@ -4,15 +4,19 @@ import org.graalvm.polyglot.Context
 import org.graalvm.polyglot.HostAccess
 import org.graalvm.polyglot.Source
 import org.sandboxpowered.fabric.api.SandboxResourcePolyglotContext
+import org.sandboxpowered.fabric.api.item.PolyglotGlobalItemManager
+import org.sandboxpowered.fabric.api.item.PolyglotItemManager
 import org.sandboxpowered.fabric.scripting.polyglot.PolyglotFileSystem
 import java.util.concurrent.Executors
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.TimeoutException
 
 class PolyglotScriptLoader {
     private val executor = Executors.newSingleThreadExecutor()
-    private val scriptContext: MutableMap<String, MutableMap<String, Context>> = HashMap()
-    private val polyglotContext: MutableMap<String, SandboxResourcePolyglotContext> = HashMap()
+    private val scriptContext: MutableMap<String, MutableMap<String, Context>> = hashMapOf()
+    private val polyglotContext: MutableMap<String, SandboxResourcePolyglotContext> = hashMapOf()
+    private val globalItemManager = PolyglotGlobalItemManager()
+    private val itemManager: MutableMap<String, PolyglotItemManager> = hashMapOf()
 
     private fun buildContext(): Context = Context.newBuilder("js", "python")
         .allowExperimentalOptions(true)
@@ -24,19 +28,22 @@ class PolyglotScriptLoader {
         return scriptContext.computeIfAbsent(resource) { HashMap() }
     }
 
-    private fun getPolyglotContext(resource: String): SandboxResourcePolyglotContext {
-        return polyglotContext.computeIfAbsent(resource) { SandboxResourcePolyglotContext(it, this) }
-    }
+    private fun getPolyglotContext(resource: String): SandboxResourcePolyglotContext =
+        polyglotContext.computeIfAbsent(resource) { SandboxResourcePolyglotContext(it, this) }
+
+    fun getItemManager(resource: String): PolyglotItemManager =
+        itemManager.computeIfAbsent(resource) { PolyglotItemManager(it, globalItemManager) }
 
     fun emitEventToAll(event: String, vararg args: Any) {
         polyglotContext.values.forEach { context ->
             context.event(event) { it(args) }
         }
     }
 
-    fun emitEventTo(resource: String, event: String, vararg args: Any) {
+    fun emitEventTo(resource: String, event: String, emitToAll: Boolean = true, vararg args: Any) {
         polyglotContext[resource]?.event(event) { it(args) }
-        emitEventToAll(resource, "$resource:$event", *args)
+        if (emitToAll)
+            emitEventToAll(resource, "$resource:$event", *args)
     }
 
     fun loadScriptContext(resource: String, scriptSource: Source) {
diff --git a/src/main/kotlin/org/sandboxpowered/fabric/util/PolyglotUtil.kt b/src/main/kotlin/org/sandboxpowered/fabric/util/PolyglotUtil.kt
@@ -4,9 +4,18 @@ import com.google.gson.*
 import org.graalvm.polyglot.Value
 
 
-fun Value.getMemberValue(identifier: String): String? =
+fun Value.getMemberValueStr(identifier: String): String? =
     if (hasMember(identifier)) getMember(identifier).asString() else null
 
+fun Value.getMemberValue(identifier: String, default: String): String =
+    if (hasMember(identifier)) getMember(identifier).asString() else default
+
+fun Value.getMemberValueInt(identifier: String): Int? =
+    if (hasMember(identifier)) getMember(identifier).asInt() else null
+
+fun Value.getMemberValue(identifier: String, default: Int): Int =
+    if (hasMember(identifier)) getMember(identifier).asInt() else default
+
 fun Value.toJSON(): JsonElement = when {
     hasArrayElements() -> JsonArray().apply {
         (0 until arraySize)
diff --git a/src/main/kotlin/org/sandboxpowered/fabric/util/map.kt b/src/main/kotlin/org/sandboxpowered/fabric/util/map.kt
@@ -1,5 +1,7 @@
 package org.sandboxpowered.fabric.util
 
+import com.google.common.collect.ImmutableMap
+
 /**
  * Removes elements from this map if the predicate returns true
  */
@@ -9,4 +11,8 @@ inline fun <K, V> MutableMap<K, V>.removeIf(predicate: (K, V) -> Boolean) {
         val (k, v) = iter.next()
         if (predicate(k, v)) iter.remove()
     }
+}
+
+operator fun <K, V> ImmutableMap.Builder<K, V>.set(key: K, value: V): ImmutableMap.Builder<K, V> {
+    return put(key, value)
 }

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ class SandboxResourcePolyglotContext(private val resource: String, private val s`
`23`	`23`	`@Export`
`24`	`24`	`fun emit(event: String, vararg args: Any) {`
`25`	`25`	`if (event.contains(':')) scriptLoader.emitEventToAll(event, *args)`
`26`		`- else scriptLoader.emitEventTo(resource, event, *args)`
	`26`	`+ else scriptLoader.emitEventTo(resource, event, args = args)`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`@Export`