Move operators and formatting to clojure

Author: object-Object

buildSrc/src/main/kotlin/caduceus/java.gradle.kts

@@ -65,8 +65,20 @@ kotlin {
     jvmToolchain(javaVersion)
 }
 
+clojure {
+    builds {
+        named("main") {
+            // remove java from clojure classpath to prevent circular dependency
+            classpath.setFrom(sourceSets.main.map { it.compileClasspath })
+        }
+    }
+}
+
 tasks {
     compileJava {
+        // allow importing clojure classes from java
+        classpath += files(sourceSets.main.map { it.clojure.classesDirectory })
+
         options.apply {
             encoding = "UTF-8"
             release = javaVersion

buildSrc/src/main/kotlin/caduceus/minecraft.gradle.kts

@@ -57,3 +57,12 @@ sourceSets {
         }
     }
 }
+
+clojure {
+    builds {
+        named("main") {
+            // we need to precompile everything, otherwise it won't be remapped
+            aotAll()
+        }
+    }
+}

common/build.gradle.kts

@@ -1,5 +1,3 @@
-import dev.clojurephant.plugin.clojure.tasks.ClojureCheck
-
 plugins {
     id("caduceus.minecraft")
 }
@@ -28,10 +26,3 @@ dependencies {
         annotationProcessor(it)
     }
 }
-
-tasks {
-    // FIXME: remove when kotlin is gone
-    named<ClojureCheck>("checkClojure") {
-        namespaces.set(listOf())
-    }
-}

common/src/main/clojure/gay/object/caduceus/casting/arithmetic.clj

@@ -0,0 +1,64 @@
+(ns gay.object.caduceus.casting.arithmetic
+  (:require [gay.object.caduceus.casting.continuation :as continuation])
+  (:import (at.petrak.hexcasting.api.casting.arithmetic Arithmetic)
+           (at.petrak.hexcasting.api.casting.arithmetic.operator OperatorBasic OperatorBinary OperatorUnary)
+           (at.petrak.hexcasting.api.casting.arithmetic.predicates IotaMultiPredicate IotaPredicate)
+           (at.petrak.hexcasting.api.casting.eval.vm SpellContinuation)
+           (at.petrak.hexcasting.api.casting.iota ContinuationIota DoubleIota)
+           (at.petrak.hexcasting.common.lib.hex HexIotaTypes)))
+
+(defn- all-of-type [iota-type]
+  (IotaMultiPredicate/all (IotaPredicate/ofType iota-type)))
+
+(defn- make-op [n op]
+  (proxy
+    [OperatorBasic]
+    [n (all-of-type HexIotaTypes/CONTINUATION)]
+    (apply [iotas _]
+      (as-> iotas v
+            (mapv #(.getContinuation %) v)
+            (apply op v)
+            (cond
+              (sequential? v) v
+              (instance? SpellContinuation v) [(ContinuationIota/new v)]
+              :else [v])))))
+
+(defn- make1 [op] (make-op 1 op))
+
+(defn- make2 [op] (make-op 2 op))
+
+(defn continuation-arithmetic []
+  (reify
+    Arithmetic
+    (arithName [_] "continuation_ops")
+    (opTypes [_] [Arithmetic/ABS
+                  Arithmetic/ADD
+                  Arithmetic/CONS
+                  Arithmetic/UNCONS])
+    (getOperator [_ pattern]
+      (condp = pattern
+        Arithmetic/ABS (make1
+                         (fn [cont]
+                           (-> cont
+                               (continuation/frames)
+                               (count)
+                               (double)
+                               (DoubleIota/new))))
+        Arithmetic/ADD (make2
+                         (fn [i j]
+                           (->> i
+                                (continuation/frames '()) ; get frames in reverse order
+                                (reduce #(.pushFrame %1 %2) j))))
+        Arithmetic/CONS (make2
+                          (fn [i j]
+                            (if (continuation/not-done? j)
+                              (.pushFrame i (.getFrame j))
+                              i)))
+        Arithmetic/UNCONS (make1
+                            (fn [cont]
+                              (mapv
+                                ContinuationIota/new
+                                (if (continuation/not-done? cont)
+                                  [(.getNext cont)
+                                   (continuation/make (.getFrame cont))]
+                                  [cont cont]))))))))

common/src/main/clojure/gay/object/caduceus/casting/continuation.clj

@@ -0,0 +1,57 @@
+(ns gay.object.caduceus.casting.continuation
+  (:require [clojure.string :as str]
+            [gay.object.caduceus.component :as component])
+  (:import (at.petrak.hexcasting.api HexAPI)
+           (at.petrak.hexcasting.api.casting.eval.vm SpellContinuation SpellContinuation$Done SpellContinuation$NotDone)
+           (at.petrak.hexcasting.common.lib.hex HexContinuationTypes)
+           (net.minecraft ChatFormatting)
+           (net.minecraft.nbt CompoundTag Tag)
+           (net.minecraft.network.chat Component)
+           (net.minecraft.resources ResourceLocation)))
+
+(defn done? [cont]
+  (instance? SpellContinuation$Done cont))
+
+(defn not-done? [cont]
+  (instance? SpellContinuation$NotDone cont))
+
+(defn make
+  ([frame] (.pushFrame SpellContinuation$Done/INSTANCE frame))
+  ([frame next] (SpellContinuation$NotDone/new frame next)))
+
+(defn frames
+  ([cont] (frames [] cont))
+  ([acc cont]
+   (if (done? cont)
+     acc
+     (recur
+       (conj acc (.getFrame cont))
+       (.getNext cont)))))
+
+(defn- frame-type-id [^CompoundTag tag]
+  (-> tag
+      (.getString HexContinuationTypes/KEY_TYPE)
+      (ResourceLocation/tryParse)
+      (or (HexAPI/modLoc "evaluate"))))
+
+(defn- display-frame [^CompoundTag tag]
+  (let [type-id (str (frame-type-id tag))]
+    (Component/translatableWithFallback
+      (format "caduceus.tooltip.continuation.frame.%s" type-id)
+      type-id)))
+
+(defn display [^CompoundTag tag]
+  (let [frames (as-> tag v
+                     (.getList v SpellContinuation/TAG_FRAME Tag/TAG_COMPOUND)
+                     (mapv display-frame v))]
+    (.withStyle
+      (if (empty? frames)
+        (component/translatable "caduceus.tooltip.continuation.done")
+        (component/translatable "caduceus.tooltip.continuation.not_done" (component/join ", " frames)))
+      ChatFormatting/RED)))
+
+(gen-class
+  :name gay.object.caduceus.casting.continuation.ContinuationUtils
+  :methods [^:static [display [net.minecraft.nbt.Tag] net.minecraft.network.chat.Component]])
+
+(defn -display [tag] (display tag))

common/src/main/clojure/gay/object/caduceus/component.clj

@@ -0,0 +1,13 @@
+(ns gay.object.caduceus.component
+  (:import (net.minecraft.network.chat Component MutableComponent)))
+
+(defn ^MutableComponent translatable [^String key & args]
+  (Component/translatable key (object-array args)))
+
+(defn ^MutableComponent join [^String separator coll]
+  (reduce
+    #(-> %1
+         (.append separator)
+         (.append ^Component %2))
+    (.copy (first coll))
+    (rest coll)))

common/src/main/clojure/gay/object/caduceus/core.clj

@@ -6,5 +6,5 @@
 
 (def ^Logger LOGGER (LogManager/getLogger MODID))
 
-(defn id ^ResourceLocation [path]
+(defn ^ResourceLocation id [path]
   (ResourceLocation/new MODID path))

common/src/main/clojure/gay/object/caduceus/registry.clj

@@ -1,10 +1,10 @@
 (ns gay.object.caduceus.registry
-  (:require [gay.object.caduceus.core :as caduceus])
+  (:require [gay.object.caduceus.core :as caduceus]
+            [gay.object.caduceus.casting.arithmetic :as arithmetic])
   (:import (at.petrak.hexcasting.api.casting ActionRegistryEntry)
            (at.petrak.hexcasting.api.casting.math HexPattern)
            (at.petrak.hexcasting.common.lib HexRegistries)
-           (at.petrak.hexcasting.common.lib.hex HexActions HexArithmetics)
-           (gay.object.caduceus.casting.arithmetic ContinuationArithmetic)))
+           (at.petrak.hexcasting.common.lib.hex HexActions HexArithmetics)))
 
 (defrecord Registrar [get-registry-key get-registry entries])
 
@@ -46,4 +46,4 @@
   (->Registrar
     (fn [] HexRegistries/ARITHMETIC)
     (fn [] HexArithmetics/REGISTRY)
-    {:continuation (make-entry "continuation" ContinuationArithmetic/INSTANCE)}))
+    {:continuation (make-lazy-entry "continuation" arithmetic/continuation-arithmetic)}))

common/src/main/java/gay/object/caduceus/mixin/MixinContinuationIotaType.java

@@ -1,6 +1,6 @@
 package gay.object.caduceus.mixin;
 
-import gay.object.caduceus.casting.iota.ContinuationUtils;
+import gay.object.caduceus.casting.continuation.ContinuationUtils;
 import net.minecraft.nbt.Tag;
 import net.minecraft.network.chat.Component;
 import org.spongepowered.asm.mixin.Mixin;
@@ -12,7 +12,7 @@
 public abstract class MixinContinuationIotaType {
     @Inject(method = "display", at = @At("HEAD"), cancellable = true)
     private void caduceus$betterDisplay(Tag tag, CallbackInfoReturnable<Component> cir) {
-        var component = ContinuationUtils.displayContinuation(tag);
+        var component = ContinuationUtils.display(tag);
         cir.setReturnValue(component);
     }
 }