repo for my hex addons :3
goodbye sleep schedule
+284
-84
+4
build.gradle.kts
+4
build.gradle.kts
···
2
2
import com.google.gson.JsonObject
3
3
import com.google.gson.JsonArray
4
4
import de.undercouch.gradle.tasks.download.Download
5
+
import net.fabricmc.loom.task.prod.ClientProductionRunTask
5
6
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
6
7
import kotlin.text.replace
7
8
···
177
178
178
179
val mergedDeps by configurations.creating
179
180
181
+
tasks.register<ClientProductionRunTask>("prodClient")
182
+
180
183
dependencies {
181
184
// To change the versions see the gradle.properties file
182
185
minecraft("com.mojang:minecraft:$minecraft_version")
···
187
190
include(modImplementation("net.fabricmc.fabric-api:fabric-api:${project.property("fabric_version")}+$minecraft_version")!!)
188
191
include(modApi("dev.onyxstudios.cardinal-components-api:cardinal-components-base:$cca_version")!!)
189
192
include(modApi("dev.onyxstudios.cardinal-components-api:cardinal-components-world:$cca_version")!!)
193
+
include(modImplementation("com.github.Chocohead:Fabric-ASM:v2.3")!!)
190
194
//include(modImplementation("io.github.0x3c50.renderer:renderer-fabric:2.1.2")!!)
191
195
//mergedDeps("org.scala-lang:scala-library:2.12.21-M2")
192
196
//include("org.scala-lang:scala-library:2.12.21-M2")
+43
-43
src/client/scala/org/net/eu/pool/mica/client/MicaClient.scala
+43
-43
src/client/scala/org/net/eu/pool/mica/client/MicaClient.scala
···
107
107
108
108
def init(): Unit =
109
109
WorldRenderEvents.BEFORE_ENTITIES.register: ctx =>
110
-
// given matrices: MatrixStack = ctx.matrixStack
111
-
// given VertexConsumerProvider = ctx.consumers
112
-
// given r: Renderer = Renderer.forLayer(TexturedRenderLayers.getEntityCutout)
113
-
// withMatrices:
114
-
// matrices.translate(ctx.camera.getPos.negate)
115
-
// var cur = BlockPos.Mutable()
116
-
// RenderSystem.teardownOverlayColor()
117
-
// for (k, i) <- AbstractRuneStorage.keys.zipWithIndex do
118
-
// val c: AbstractRuneStorage = ctx.world.getComponent(k)
119
-
// withMatrices:
120
-
// val shift = RuneShift(i)
121
-
// matrices.translate(shift.x / 4.0, shift.y / 8.0, shift.z / 4.0)
122
-
// c.contents.forEach: (pos, rune) =>
123
-
// cur.set(pos)
124
-
// // TODO: more quads
125
-
// withMatrices:
126
-
// matrices.translate(cur.getX, cur.getY, cur.getZ)
127
-
// val color: RGB = (1, 1, 1, 1)
128
-
// val light: I2 = (255, 0)
129
-
// val overlay: I2 = (0, 10) // magic number owo scary
130
-
// r.sprite = Some(rune.surface)
131
-
// r.quad(
132
-
// Vertex(pos = (-0.25f, 0.125f, -0.25f), uv = (0, 0), color = color, light = light, overlay = overlay),
133
-
// Vertex(pos = (-0.25f, 0.125f, 0.25f), uv = (0, 1), color = color, light = light, overlay = overlay),
134
-
// Vertex(pos = (0.25f, 0.125f, 0.25f), uv = (1, 1), color = color, light = light, overlay = overlay),
135
-
// Vertex(pos = (0.25f, 0.125f, -0.25f), uv = (1, 0), color = color, light = light, overlay = overlay),
136
-
// normal = (0, 1, 0),
137
-
// )
138
-
// r.quad(
139
-
// Vertex(pos = (-0.25f, 0f, -0.25f), uv = (0, 0), color = color, light = light, overlay = overlay),
140
-
// Vertex(pos = (-0.25f, 0.125f, -0.25f), uv = (1, 0), color = color, light = light, overlay = overlay),
141
-
// Vertex(pos = (0.25f, 0.125f, -0.25f), uv = (1, 1), color = color, light = light, overlay = overlay),
142
-
// Vertex(pos = (0.25f, 0f, -0.25f), uv = (0, 1), color = color, light = light, overlay = overlay),
143
-
// normal = (0, 0, -1)
144
-
// )
145
-
// r.sprite = Some(rune.sprite)
146
-
// r.quad(
147
-
// Vertex(pos = (-0.25f, 0.126f, -0.25f), uv = (0, 0), color = color, light = light, overlay = overlay),
148
-
// Vertex(pos = (-0.25f, 0.126f, 0.25f), uv = (0, 1), color = color, light = light, overlay = overlay),
149
-
// Vertex(pos = (0.25f, 0.126f, 0.25f), uv = (1, 1), color = color, light = light, overlay = overlay),
150
-
// Vertex(pos = (0.25f, 0.126f, -0.25f), uv = (1, 0), color = color, light = light, overlay = overlay),
151
-
// normal = (0, 1, 0),
152
-
// )
110
+
given matrices: MatrixStack = ctx.matrixStack
111
+
given VertexConsumerProvider = ctx.consumers
112
+
given r: Renderer = Renderer.forLayer(TexturedRenderLayers.getEntityCutout)
113
+
withMatrices:
114
+
matrices.translate(ctx.camera.getPos.negate)
115
+
var cur = BlockPos.Mutable()
116
+
RenderSystem.teardownOverlayColor()
117
+
for (k, i) <- AbstractRuneStorage.keys.zipWithIndex do
118
+
val c: AbstractRuneStorage = ctx.world.getComponent(k)
119
+
withMatrices:
120
+
val shift = RuneShift(i)
121
+
matrices.translate(shift.x / 4.0, shift.y / 8.0, shift.z / 4.0)
122
+
c.contents.forEach: (pos, rune) =>
123
+
cur.set(pos)
124
+
// TODO: more quads
125
+
withMatrices:
126
+
matrices.translate(cur.getX, cur.getY, cur.getZ)
127
+
val color: RGB = (1, 1, 1, 1)
128
+
val light: I2 = (255, 0)
129
+
val overlay: I2 = (0, 10) // magic number owo scary
130
+
r.sprite = Some(rune.surface)
131
+
r.quad(
132
+
Vertex(pos = (-0.25f, 0.125f, -0.25f), uv = (0, 0), color = color, light = light, overlay = overlay),
133
+
Vertex(pos = (-0.25f, 0.125f, 0.25f), uv = (0, 1), color = color, light = light, overlay = overlay),
134
+
Vertex(pos = (0.25f, 0.125f, 0.25f), uv = (1, 1), color = color, light = light, overlay = overlay),
135
+
Vertex(pos = (0.25f, 0.125f, -0.25f), uv = (1, 0), color = color, light = light, overlay = overlay),
136
+
normal = (0, 1, 0),
137
+
)
138
+
r.quad(
139
+
Vertex(pos = (-0.25f, 0f, -0.25f), uv = (0, 0), color = color, light = light, overlay = overlay),
140
+
Vertex(pos = (-0.25f, 0.125f, -0.25f), uv = (1, 0), color = color, light = light, overlay = overlay),
141
+
Vertex(pos = (0.25f, 0.125f, -0.25f), uv = (1, 1), color = color, light = light, overlay = overlay),
142
+
Vertex(pos = (0.25f, 0f, -0.25f), uv = (0, 1), color = color, light = light, overlay = overlay),
143
+
normal = (0, 0, -1)
144
+
)
145
+
r.sprite = Some(rune.sprite)
146
+
r.quad(
147
+
Vertex(pos = (-0.25f, 0.126f, -0.25f), uv = (0, 0), color = color, light = light, overlay = overlay),
148
+
Vertex(pos = (-0.25f, 0.126f, 0.25f), uv = (0, 1), color = color, light = light, overlay = overlay),
149
+
Vertex(pos = (0.25f, 0.126f, 0.25f), uv = (1, 1), color = color, light = light, overlay = overlay),
150
+
Vertex(pos = (0.25f, 0.126f, -0.25f), uv = (1, 0), color = color, light = light, overlay = overlay),
151
+
normal = (0, 1, 0),
152
+
)
153
153
()
154
154
155
155
class ModelBuilder extends ModelSupplier:
+1
src/main/resources/mica.mixins.json
+1
src/main/resources/mica.mixins.json
+203
-41
src/main/scala/org/net/eu/pool/mica/Mica.scala
+203
-41
src/main/scala/org/net/eu/pool/mica/Mica.scala
···
20
20
import net.minecraft.server.world.ServerWorld
21
21
import net.minecraft.sound.{SoundCategory, SoundEvent, SoundEvents}
22
22
import net.minecraft.state.property.Property
23
-
import net.minecraft.text.TextColor
23
+
import net.minecraft.text.{TextCodecs, TextColor, Texts}
24
24
import net.minecraft.util.{Hand, Rarity, Uuids}
25
25
import net.minecraft.util.shape.VoxelShapes
26
26
import net.minecraft.world.World.ExplosionSourceType
27
27
import org.net.eu.pool.mica
28
-
import org.net.eu.pool.mica.CraftTrinketRune.Effect
29
28
import org.slf4j.{Logger, LoggerFactory}
30
29
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable
31
30
31
+
import java.nio.file.{Files, Path}
32
32
import java.util.{Optional, UUID}
33
33
import java.util.stream.LongStream
34
34
import scala.::
···
37
37
import scala.annotation.targetName
38
38
import scala.collection.immutable.{AbstractSet, SortedSet}
39
39
import scala.compiletime.constValue
40
+
import scala.runtime.ObjectRef
40
41
import scala.util.boundary
41
42
// ifversion(>=2100, <[[
42
43
import net.minecraft.storage.{ReadView, WriteView}
···
76
77
import scala.language.experimental.erasedDefinitions
77
78
import scala.quoted.{Expr, Quotes}
78
79
import scala.reflect.ClassTag
79
-
import scala.tools.nsc.io.Path
80
80
import scala.util.chaining.scalaUtilChainingOps
81
81
82
82
private given ModID = ModID("mica")
···
244
244
* information about changes made (for example, the old [[Block]]). In the case you have ''nothing'' valuable to
245
245
* return, use [[Unit]].
246
246
*/
247
-
type Return: ValueType
247
+
type Return: {ValueType, ClassTag}
248
248
given returnType: ValueType[Return] = deferred
249
249
250
250
/**
···
556
556
//def dependentCodec[T, R](arg: Codec[T], rhs: [R] )
557
557
558
558
// y'know, I should really make a generic Boxed type
559
-
case class BoxedSideEffect(effect: SideEffect, data: effect.Data)
559
+
case class BoxedSideEffect(effect: SideEffect, data: effect.Data):
560
+
def check()(using World): Unit = effect.check(data)
561
+
def check(player: PlayerEntity)(using World): Unit = effect.check(data, player)
562
+
def execute()(using World): (effect.Return, effect.RevertData) = effect.execute(data)
563
+
def execute(player: PlayerEntity)(using World): (effect.Return, effect.RevertData) = effect.execute(data, player)
564
+
def unexecute(`return`: effect.Return, revert: effect.RevertData)(using World): Unit = effect.unexecute(data, `return`, revert)
560
565
561
566
// divert(-1)
562
567
/**
···
581
586
582
587
@register("quote")
583
588
object QuoteRune extends Rune:
584
-
override type Data = Seq[Rune]
589
+
override type Data = Seq[(Rune, RuneRef)]
585
590
override def surfaceSprite: Identifier = Rune.BASIC_TEXTURE
586
-
override def read(rhs: List[(Rune, RuneRef)])(using ref: RuneRef, world: World): (Seq[Rune], List[(Rune, RuneRef)]) =
591
+
override def read(rhs: List[(Rune, RuneRef)])(using ref: RuneRef, world: World): (Seq[(Rune, RuneRef)], List[(Rune, RuneRef)]) =
587
592
@throws[RuneError]
588
-
def worker(rhs: List[(Rune, RuneRef)])(using ref: RuneRef): (List[Rune], List[(Rune, RuneRef)]) =
593
+
def worker(rhs: List[(Rune, RuneRef)])(using ref: RuneRef): (List[(Rune, RuneRef)], List[(Rune, RuneRef)]) =
589
594
rhs match
590
595
case Nil => throw RuneError(Text.literal("Quote with no corresponding unquote"))
591
596
case (QuoteRune, given RuneRef)::xs =>
592
597
val (t, xt) = worker(xs)
593
598
val (u, xu) = worker(xt)
594
-
(t:::EndQuoteRune::u, xu)
599
+
(t:::(EndQuoteRune, summon[RuneRef])::u, xu)
595
600
case (EndQuoteRune, r)::xs => (Nil, xs)
596
601
case x::xs =>
597
602
val t = worker(xs)
598
-
(x._1::t._1, t._2)
603
+
(x::t._1, t._2)
599
604
worker(rhs)
600
-
override def execute(data: Seq[Rune], frame: BoxedThunk): BoxedThunk =
605
+
override def execute(data: Seq[(Rune, RuneRef)], frame: BoxedThunk): BoxedThunk =
601
606
frame.tag.accept(frame.data, data.map(BoxedValue(_)))
602
607
register:
603
608
item.register()
···
779
784
m.append(" ").append(x.show)
780
785
m.append(")")
781
786
case Seq() => Text.literal("()").styled(_.withColor(color))
782
-
given ValueType[Rune]:
787
+
given ValueType[(Rune, RuneRef)]:
783
788
val color = TextColor.fromRgb(0xffe46e)
784
-
override def eq[U: ValueType as v](x: Rune, y: U): Boolean = v.cast[Rune](y).exists(y => x eq y)
785
-
override def show(x: Rune): Text = Text.literal(registryFor[Rune].getId(x).toTranslationKey("mica.runes"))
789
+
override def eq[U: ValueType as v](x: (Rune, RuneRef), y: U): Boolean = v.cast[(Rune, RuneRef)](y).exists(y => x._1 eq y._1)
790
+
override def show(x: (Rune, RuneRef)): Text = Text.literal(registryFor[Rune].getId(x._1).toTranslationKey("mica.runes"))
786
791
787
792
@register("fatboy_slim")
788
793
object PosLiteral extends Rune:
···
810
815
if entity == null then
811
816
throw RuneError(Text.literal("Could not find ").append(summon[ValueType[EntityRef]].show(data._2)).append(" in the world"))(using data._1)
812
817
val pos = entity.getPos
813
-
entity.setPosition(data._1.floatPos)
818
+
val newPos = data._1.floatPos
819
+
entity.setPosition(newPos)
820
+
entity.setVelocity(0, 0, 0)
821
+
world.playSound(entity, pos.x, pos.y, pos.z, SoundEvents.ENTITY_ENDERMAN_TELEPORT, SoundCategory.PLAYERS)
822
+
world.playSound(entity, newPos.x, newPos.y, newPos.z, SoundEvents.ENTITY_ENDERMAN_TELEPORT, SoundCategory.PLAYERS)
814
823
entity match
815
824
case player: ServerPlayerEntity =>
816
-
val delta = pos.distanceTo(data._1.floatPos)
825
+
val delta = pos.distanceTo(newPos)
817
826
println(s"${player} moved ${delta} blocks by teleporting")
818
827
if delta >= 32 then
819
828
println("and gets the advancement")
820
829
val adv = player.getServer.getAdvancementLoader.get(Identifier.of(modid, "without_me"))
821
830
player.getAdvancementTracker.grantCriterion(adv, "mojang_won\'t_let_me_be")
831
+
case _ =>
822
832
((), pos)
823
833
override def unexecute(data: (RuneRef, EntityRef), `return`: Unit, revert: Vec3d)(using world: World): Unit =
824
834
data._2.entity.setPosition(revert)
···
838
848
Codec.LONG.fieldOf("pos").xmap(BlockPos.fromLong, _.asLong).forGetter(_.pos),
839
849
Codec.INT.fieldOf("dir").xmap(RuneShift.apply, _.value).forGetter(_.shift),
840
850
).apply(i, RuneRef(_, _))
841
-
given Codec[((RuneRef, EntityRef))] = RecordCodecBuilder.create: i =>
842
-
i.group(
843
-
given_Codec_RuneRef.fieldOf("to").forGetter(_._1),
844
-
given_Codec_EntityRef.fieldOf("from").forGetter(_._2),
845
-
).apply(i, (_, _))
846
-
given Codec[((RuneRef, BoxedThunk))] = RecordCodecBuilder.create: i =>
847
-
i.group(
848
-
given_Codec_RuneRef.fieldOf("to").forGetter(_._1),
849
-
`dispatch codec for boxed thunk frames`.fieldOf("from").forGetter(_._2),
850
-
).apply(i, (_, _))
851
+
//given Codec[((RuneRef, EntityRef))] = RecordCodecBuilder.create: i =>
852
+
// i.group(
853
+
// given_Codec_RuneRef.fieldOf("to").forGetter(_._1),
854
+
// given_Codec_EntityRef.fieldOf("from").forGetter(_._2),
855
+
// ).apply(i, (_, _))
856
+
//given Codec[((RuneRef, BoxedThunk))] = RecordCodecBuilder.create: i =>
857
+
// i.group(
858
+
// given_Codec_RuneRef.fieldOf("to").forGetter(_._1),
859
+
// `dispatch codec for boxed thunk frames`.fieldOf("from").forGetter(_._2),
860
+
// ).apply(i, (_, _))
851
861
852
862
given `given_Codec_java.lang.Double`: Codec[java.lang.Double] = Codec.DOUBLE
853
863
864
+
given [T: Codec as c] => Codec[Option[T]] = c.optionalFieldOf("present").codec().xmap(_.map[Option[T]](Some(_)).orElse(None), _.fold(Optional.empty)(Optional.of))
865
+
866
+
@register("foreach")
867
+
object ThothRune extends BinaryRune:
868
+
register { item.register(); registerFrames() }
869
+
override type Arg0 = Seq[BoxedValue]
870
+
override type Arg1 = Seq[BoxedValue]
871
+
override type Return = Seq[BoxedValue]
872
+
@register("foreach/sub/_")
873
+
object CollectFrame extends ThunkFrame:
874
+
override type Data = Seq[BoxedValue]
875
+
override given given_Codec_Data: Codec[Seq[BoxedValue]] = seqCodec
876
+
override def accept[T: ValueType](data: Seq[BoxedValue], value: T): BoxedThunk = BoxedThunk(CollectFrame, data :+ BoxedValue(value))
877
+
override def run(x: Seq[BoxedValue], y: Seq[BoxedValue]): Seq[BoxedValue] =
878
+
val insts = parseRunes(x.map(_.cast[(Rune, RuneRef)].get).toList)(using null: World) // FIXME
879
+
val base = BoxedThunk(CollectFrame, Vector())
880
+
y.flatMap: y =>
881
+
val frame = interpretRunes(insts, base)
882
+
frame.tag.accept(frame.data, y.value).narrow(CollectFrame).get.data
883
+
884
+
case class Derived[T, R](value: T):
885
+
private var state: Option[R] = None
886
+
def apply(f: T => R): R = state.getOrElse { state = Some(f(value)); state.get }
887
+
object Derived:
888
+
given [T: Codec as c, R] => Codec[Derived[T, R]] = c.xmap(Derived(_), _.value)
889
+
890
+
given ValueType[BoxedValue]:
891
+
override def eq[U: ValueType](x: BoxedValue, y: U): Boolean =
892
+
import x.given
893
+
summon[ValueType[x.T]].eq(x.value, y)
894
+
override def cast[R: ClassTag](x: BoxedValue): Option[R] =
895
+
import x.given
896
+
summon[ValueType[x.T]].cast(x.value)
897
+
override def show(x: BoxedValue): Text =
898
+
import x.given
899
+
summon[ValueType[x.T]].show(x.value)
900
+
901
+
@register("defer")
902
+
object DeferEffectRune extends SimpleRune:
903
+
@register("defer")
904
+
object Effect extends SideEffect:
905
+
override type Data = Derived[Seq[(Rune, RuneRef)], BoxedSideEffect]
906
+
override type Return = BoxedValue
907
+
override given given_ValueType_Return: ValueType[Return] = given_ValueType_BoxedValue
908
+
override type RevertData = Any
909
+
private def computeEffect(data: Derived[Seq[(Rune, RuneRef)], BoxedSideEffect])(using World) = data: p =>
910
+
val parse = parseRunes(p.toList)
911
+
interpretForSideEffect(parse).get
912
+
override def check(data: Derived[Seq[(Rune, RuneRef)], BoxedSideEffect])(using World): Unit = computeEffect(data).check()
913
+
override def check(data: Derived[Seq[(Rune, RuneRef)], BoxedSideEffect], player: PlayerEntity)(using World): Unit = computeEffect(data).check(player)
914
+
override def execute(data: Derived[Seq[(Rune, RuneRef)], BoxedSideEffect])(using World): (BoxedValue, Any) =
915
+
val effect = computeEffect(data)
916
+
import effect.given
917
+
val x = effect.execute()
918
+
919
+
(BoxedValue(x._1)(using effect.effect.given_ValueType_Return), x._2)
920
+
override def execute(data: Derived[Seq[(Rune, RuneRef)], BoxedSideEffect], player: PlayerEntity)(using World): (BoxedValue, Any) =
921
+
val effect = computeEffect(data)
922
+
import effect.given
923
+
val x = effect.execute(player)
924
+
925
+
(BoxedValue(x._1)(using effect.effect.given_ValueType_Return), x._2)
926
+
override def unexecute(data: Derived[Seq[(Rune, RuneRef)], BoxedSideEffect], `return`: BoxedValue, revert: Any)(using World): Unit =
927
+
val effect = computeEffect(data)
928
+
import effect.given
929
+
effect.unexecute(`return`.cast[effect.effect.Return](using effect.effect.given_ValueType_Return).get, revert.asInstanceOf[effect.effect.RevertData])
930
+
@register("defer/0")
931
+
object Frame extends ThunkFrame:
932
+
override type Data = BoxedThunk
933
+
override def accept[T: ValueType as v](data: BoxedThunk, value: T): BoxedThunk = data.tag.accept(data.data, BoxedSideEffect(Effect, Derived(v.cast[Seq[BoxedValue]](value).get.map(_.cast[(Rune, RuneRef)].get))))
934
+
override def execute(frame: BoxedThunk): BoxedThunk = BoxedThunk(Frame, frame)
935
+
register { item.register() }
936
+
937
+
given [T: Codec as t, U: Codec as u] => Codec[(T, U)] =
938
+
RecordCodecBuilder.create: i =>
939
+
i.group(
940
+
t.fieldOf("t").forGetter(_._1),
941
+
u.fieldOf("u").forGetter(_._2)
942
+
).apply(i, (_, _))
943
+
given Codec[Text] = TextCodecs.CODEC
944
+
945
+
@register("doublecast")
946
+
object DoubleCastRune extends BinaryRune:
947
+
override type Arg0 = BoxedSideEffect
948
+
override type Arg1 = BoxedSideEffect
949
+
override type Return = BoxedSideEffect
950
+
override given given_ValueType_Arg0: ValueType[Return] = given_ValueType_BoxedSideEffect
951
+
override given given_ValueType_Arg1: ValueType[Return] = given_ValueType_BoxedSideEffect
952
+
override given given_ValueType_Return: ValueType[Return] = given_ValueType_BoxedSideEffect
953
+
override given given_Codec_Arg0: Codec[BoxedSideEffect] = `dispatch codec for boxed side-effects`
954
+
override given given_Codec_Arg1: Codec[BoxedSideEffect] = `dispatch codec for boxed side-effects`
955
+
// given Codec[BoxedSideEffect] = `dispatch codec for boxed side-effects`
956
+
object Effect extends SideEffect:
957
+
override type Data = (BoxedSideEffect, BoxedSideEffect)
958
+
override type Return = BoxedValue
959
+
override type RevertData = (BoxedValue, Any, Any)
960
+
override given dataCodec: Codec[Data] = given_Codec_T_U(using `dispatch codec for boxed side-effects`, `dispatch codec for boxed side-effects`)
961
+
override given given_ValueType_Return: ValueType[Return] = given_ValueType_BoxedValue
962
+
override def check(data: (BoxedSideEffect, BoxedSideEffect))(using world: World): Unit =
963
+
data._1.check()
964
+
data._2.check()
965
+
override def check(data: (BoxedSideEffect, BoxedSideEffect), player: PlayerEntity)(using world: World): Unit =
966
+
data._1.check(player)
967
+
data._2.check(player)
968
+
override def execute(data: (BoxedSideEffect, BoxedSideEffect))(using world: World): (BoxedValue, (BoxedValue, Any, Any)) =
969
+
val l = data._1.execute()
970
+
try
971
+
val r = data._2.execute()
972
+
973
+
(BoxedValue(r._1)(using data._2.effect.given_ValueType_Return), (BoxedValue(l._1)(using data._1.effect.given_ValueType_Return), l._2, r._2))
974
+
catch case e: Exception =>
975
+
data._1.unexecute(l._1, l._2)
976
+
throw e
977
+
978
+
override def execute(data: (BoxedSideEffect, BoxedSideEffect), player: PlayerEntity)(using World): (BoxedValue, (BoxedValue, Any, Any)) =
979
+
val l = data._1.execute(player)
980
+
try
981
+
val r = data._2.execute(player)
982
+
983
+
(BoxedValue(r._1)(using data._2.effect.given_ValueType_Return), (BoxedValue(l._1)(using data._1.effect.given_ValueType_Return), l._2, r._2))
984
+
catch case e: Exception =>
985
+
data._1.unexecute(l._1, l._2)
986
+
throw e
987
+
988
+
override def unexecute(data: (BoxedSideEffect, BoxedSideEffect), `return`: BoxedValue, revert: (BoxedValue, Any, Any))(using world: World): Unit =
989
+
try data._2.unexecute(`return`.asInstanceOf[data._2.effect.Return], revert._3.asInstanceOf[data._2.effect.RevertData])
990
+
finally data._1.unexecute(revert._1.value.asInstanceOf[data._1.effect.Return], revert._2.asInstanceOf[data._1.effect.RevertData])
991
+
override def surfaceSprite: Identifier = Rune.SPELL_TEXTURE
992
+
override def run(x: BoxedSideEffect, y: BoxedSideEffect): BoxedSideEffect = BoxedSideEffect(Effect, (x, y))
993
+
register { item.register() }
994
+
854
995
val sideEffectComponent = ComponentType.builder().codec(codec[BoxedSideEffect]).packetCodec(PacketCodecs.codec(codec[BoxedSideEffect])).build()
855
996
val runicTrinketItem =
856
997
val r = cursedRegister(Identifier.of("mica", "trinket"), Item.Settings().rarity(Rarity.UNCOMMON)):
···
892
1033
override def execute(data: RuneRef, frame: BoxedThunk): BoxedThunk = BoxedThunk(Frame, (data, frame))
893
1034
register:
894
1035
CraftTrinketRune.item.register()
895
-
given Codec[(RuneRef, BoxedSideEffect)] = Codec.pair(codec[RuneRef], codec[BoxedSideEffect]).xmap(p => (p.getFirst, p.getSecond), p => Pair(p._1, p._2))
1036
+
//given Codec[(RuneRef, BoxedSideEffect)] = Codec.pair(codec[RuneRef], codec[BoxedSideEffect]).xmap(p => (p.getFirst, p.getSecond), p => Pair(p._1, p._2))
896
1037
@register("reveal")
897
1038
private[mica] object RevealRune extends Rune:
898
1039
override type Data = RuneRef
1040
+
@register("reveal")
1041
+
object Effect extends SideEffect:
1042
+
override type Data = (RuneRef, Text)
1043
+
override type Return = Unit
1044
+
override type RevertData = Unit
1045
+
override def check(data: (RuneRef, Text))(using world: World): Unit = ()
1046
+
override def execute(data: (RuneRef, Text), player: PlayerEntity)(using World): (Unit, Unit) =
1047
+
val p = data._1.floatPos
1048
+
summon[World].playSound(player, p.x, p.y, p.z, SoundEvents.BLOCK_AMETHYST_BLOCK_CHIME, SoundCategory.PLAYERS)
1049
+
player match
1050
+
case s: ServerPlayerEntity => s.sendMessage(data._2, false)
1051
+
case _ => ()
1052
+
((), ())
1053
+
override def execute(data: (RuneRef, Text))(using world: World): (Unit, Unit) = ((), ())
1054
+
override def unexecute(data: (RuneRef, Text), `return`: Unit, revert: Unit)(using world: World): Unit = ()
899
1055
@register("reveal/0")
900
1056
object Frame extends ThunkFrame:
901
1057
override type Data = (RuneRef, BoxedThunk)
902
-
override def accept[T: ValueType](data: (RuneRef, BoxedThunk), value: T): BoxedThunk = ???
903
-
given Codec[(RuneRef, BoxedThunk)] =
904
-
RecordCodecBuilder.create: i =>
905
-
i.group(
906
-
codec[RuneRef].fieldOf("_1").forGetter(_._1),
907
-
codec[BoxedThunk].fieldOf("_2").forGetter(_._2),
908
-
).apply(i, (_, _))
1058
+
override def accept[T: ValueType as v](data: (RuneRef, BoxedThunk), value: T): BoxedThunk = data._2.tag.accept(data._2.data, BoxedSideEffect(Effect, (data._1, v.show(value))))
1059
+
// given Codec[(RuneRef, BoxedThunk)] =
1060
+
// RecordCodecBuilder.create: i =>
1061
+
// i.group(
1062
+
// codec[RuneRef].fieldOf("_1").forGetter(_._1),
1063
+
// codec[BoxedThunk].fieldOf("_2").forGetter(_._2),
1064
+
// ).apply(i, (_, _))
909
1065
override def read(rhs: List[(Rune, RuneRef)])(using ref: RuneRef, world: World): (RevealRune.Data, List[(Rune, RuneRef)]) = (summon, rhs)
910
1066
override def execute(data: RuneRef, frame: BoxedThunk): BoxedThunk = BoxedThunk(Frame, (data, frame))
911
1067
register:
···
975
1131
interpretForSideEffect(boxedRunes) match
976
1132
case Some(value) =>
977
1133
println(s"Hello ladies and gentlemen! Today we will be executing ${value}! Are we on the client? ${given_World.isClient}!")
978
-
value.effect.check(value.data)
979
-
value.effect.execute(value.data)
1134
+
value.effect.check(value.data, ctx.getPlayer)
1135
+
value.effect.execute(value.data, ctx.getPlayer)
980
1136
case None =>
981
1137
ctx.getPlayer.sendMessage(Text.literal("Nothing seems to happen..."), true)
982
1138
catch
···
1031
1187
override type Data = EntityRef
1032
1188
override def read(rhs: List[(Rune, RuneRef)])(using ref: RuneRef, world: World): (EntityRef, List[(Rune, RuneRef)]) =
1033
1189
val uuid = EntityRef(Uuids.toUuid(Array(ref.heap0, ref.heap1, ref.heap2, ref.heap3)))
1034
-
println(s"playerliteral${ref}sayswhat? ${uuid} obviously")
1190
+
1035
1191
(uuid, rhs)
1036
1192
override def execute(data: EntityRef, frame: BoxedThunk): BoxedThunk =
1037
-
println(s"AND HE SHOOTS ${data} TO THE STACK")
1038
1193
frame.tag.accept(frame.data, data)
1039
1194
override def fillHeap(using ref: RuneRef, player: PlayerEntity, world: World)(): Unit =
1040
1195
val uuid = Uuids.toIntArray(player.getUuid)
···
1042
1197
ref.heap1 = uuid(1)
1043
1198
ref.heap2 = uuid(2)
1044
1199
ref.heap3 = uuid(3)
1045
-
println(s"who up player literal they ${uuid.mkString("Array(", ", ", ")")} (${ref}) on the client? ${world.isClient}")
1046
1200
register:
1047
1201
PlayerLiteral.item.register()
1048
1202
···
1249
1403
EndQuoteRune.item.register()
1250
1404
// divert
1251
1405
1252
-
given seqCodec: [T: Codec as c] => Codec[Seq[T]] = Codec.list[T](c).xmap(_.toSeq, locally(_))
1406
+
given seqCodec: [T: Codec as c] => Codec[Seq[T]] = c.listOf().xmap(_.toSeq, locally(_))
1253
1407
given unitCodec: Codec[Unit] = Codec.unit(())
1254
1408
given nothingCodec: Codec[Nothing] = Codec.of(new Encoder[Nothing]:
1255
1409
override def encode[T](input: Nothing, ops: DynamicOps[T], prefix: T): DataResult[T] = input, Decoder.error("Nothing codec"))
···
1271
1425
def init(): Unit =
1272
1426
runeProbe.register()
1273
1427
Registry.register(Registries.DATA_COMPONENT_TYPE, Identifier.of(modid, "effect"), sideEffectComponent)
1274
-
register()
1428
+
register()
1429
+
println(s"Rune registry contains ${registryFor[Rune].size} runes")
1430
+
val config = Path.of("config/mica:extra_classes.txt")
1431
+
if Files.exists(config) then
1432
+
Files.readAllLines(config).forEach: line =>
1433
+
val ary = line.split("\t")
1434
+
ary(0) match
1435
+
case "INVOKE" =>
1436
+
Class.forName(ary(1)).newInstance().asInstanceOf[Runnable].run()
+33
src/main/scala/org/net/eu/pool/mica/Plugin.scala
+33
src/main/scala/org/net/eu/pool/mica/Plugin.scala
···
1
+
package org.net.eu.pool.mica
2
+
3
+
import com.chocohead.mm.api.ClassTinkerers
4
+
import org.objectweb.asm.tree.ClassNode
5
+
import org.spongepowered.asm.mixin.extensibility.{IMixinConfigPlugin, IMixinInfo}
6
+
7
+
import java.nio.file.{Files, Path}
8
+
import java.util
9
+
import java.util.Base64
10
+
import scala.collection.mutable
11
+
import scala.collection.convert.ImplicitConversions.given
12
+
13
+
class Plugin extends IMixinConfigPlugin:
14
+
private val mixinClasses = mutable.Buffer[String]()
15
+
override def onLoad(mixinPackage: String): Unit =
16
+
val config = Path.of("config/mica:extra_classes.txt")
17
+
if Files.exists(config) then
18
+
Files.readAllLines(config).forEach: line =>
19
+
val ary = line.split("\t")
20
+
ary(0) match
21
+
case "CLASS" =>
22
+
//<[[
23
+
ClassTinkerers.define(ary(1), Base64.getDecoder.decode(ary(2)))
24
+
case "MIXIN" =>
25
+
ClassTinkerers.define(ary(1), Base64.getDecoder.decode(ary(2)));
26
+
mixinClasses += ary(1)
27
+
//]]>
28
+
override def getRefMapperConfig: String = null
29
+
override def shouldApplyMixin(targetClassName: String, mixinClassName: String): Boolean = true
30
+
override def acceptTargets(myTargets: util.Set[String], otherTargets: util.Set[String]): Unit = ()
31
+
override def preApply(targetClassName: String, targetClass: ClassNode, mixinClassName: String, mixinInfo: IMixinInfo): Unit = ()
32
+
override def postApply(targetClassName: String, targetClass: ClassNode, mixinClassName: String, mixinInfo: IMixinInfo): Unit = ()
33
+
override def getMixins: util.List[String] = mixinClasses.toVector