repo for my hex addons :3
refactoring
+128
-60
+1
-1
build.gradle.kts
+1
-1
build.gradle.kts
···
184
184
include("maven.modrinth:cardinal-components-api:$cca_version")
185
185
modImplementation("folk.sisby:crunchy-crunchy-advancements:1.7.1+1.21")
186
186
include(modImplementation("com.github.Chocohead:Fabric-ASM:v2.3")!!)
187
-
modImplementation("net.modfest:fireblanket:0.8.3+toybox-1.21.7") { exclude("com.github.bawnorton.mixinsquared") }
187
+
modCompileOnly("net.modfest:fireblanket:0.8.3+toybox-1.21.7") { exclude("com.github.bawnorton.mixinsquared") }
188
188
include(modImplementation("com.github.Bawnorton.MixinSquared:mixinsquared-common:0.3.3")!!)
189
189
include(modImplementation("com.github.Bawnorton.MixinSquared:mixinsquared-fabric:0.3.3")!!)
190
190
modImplementation("com.github.afamiliarquiet:be-a-doll:1.0.0")
+6
-2
plugin/src/main/kotlin/org/eu/net/pool/mc_plugin/Plugin.kt
+6
-2
plugin/src/main/kotlin/org/eu/net/pool/mc_plugin/Plugin.kt
···
14
14
import org.gradle.api.provider.Property
15
15
import org.gradle.api.provider.Provider
16
16
import org.gradle.api.tasks.AbstractCopyTask
17
+
import org.gradle.api.tasks.Exec
17
18
import org.gradle.api.tasks.Input
18
19
import org.gradle.api.tasks.InputFiles
19
20
import org.gradle.api.tasks.OutputFile
···
21
22
import org.gradle.api.tasks.TaskAction
22
23
import org.gradle.kotlin.dsl.get
23
24
import org.gradle.language.jvm.tasks.ProcessResources
25
+
import java.io.File
24
26
25
27
typealias PT = context(Project) SourceSet.(String, Pair<String, Task>.(Provider<Directory>) -> Unit) -> Unit
28
+
29
+
val m4path = System.getenv("PATH").split(':').onEach { println(it) }.first { File("$it/m4").exists() } + "/m4"
26
30
27
31
class Plugin: Plugin<Project> {
28
32
override fun apply(project: Project) {
···
58
62
project.fileTree(inDir).files.forEach {
59
63
project.file("${outDir.get()}/${it.relativeTo(inDir.asFile)}").parentFile.mkdirs()
60
64
project.exec {
61
-
commandLine("m4", "-R", frozen.get().asFile.path, it.path)
65
+
commandLine(m4path, "-R", frozen.get().asFile.path, it.path)
62
66
standardOutput = project.file("${outDir.get()}/${it.relativeTo(inDir.asFile)}").outputStream()
63
67
}
64
68
}
···
96
100
@TaskAction
97
101
fun run() {
98
102
project.exec {
99
-
val args = mutableListOf("m4", "-F", frozenFile.get().asFile.path)
103
+
val args = mutableListOf(m4path, "-F", frozenFile.get().asFile.path)
100
104
globals.get().forEach { k, v -> args.add("-D$k=$v") }
101
105
macroFiles.get().forEach { args.add(it.asFile.path) }
102
106
commandLine = args
+17
-5
src/client/scala/org/net/eu/pool/mica/client/MicaClient.scala
+17
-5
src/client/scala/org/net/eu/pool/mica/client/MicaClient.scala
···
6
6
import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking
7
7
import net.fabricmc.fabric.api.client.rendering.v1.{WorldRenderContext, WorldRenderEvents}
8
8
import net.fabricmc.fabric.api.datagen.v1.FabricDataGenerator
9
-
import net.fabricmc.fabric.api.datagen.v1.provider.FabricAdvancementProvider
9
+
import net.fabricmc.fabric.api.datagen.v1.provider.{FabricAdvancementProvider, FabricLootTableProvider, SimpleFabricLootTableProvider}
10
10
import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking
11
11
import net.fabricmc.fabric.api.renderer.v1.render.RenderLayerHelper
12
12
import net.minecraft.advancement.criterion.{Criteria, ImpossibleCriterion}
···
16
16
import net.minecraft.client.render.{BlockRenderLayer, OverlayTexture, RenderLayer, RenderLayers, TexturedRenderLayers, VertexConsumer, VertexConsumerProvider}
17
17
import net.minecraft.client.texture.{Sprite, SpriteAtlasTexture, SpriteLoader}
18
18
import net.minecraft.client.util.math.MatrixStack
19
-
import net.minecraft.util.{AssetInfo, Identifier}
19
+
import net.minecraft.util.{ActionResult, AssetInfo, Hand, Identifier}
20
20
import net.minecraft.util.math.{BlockPos, Direction, MathHelper}
21
21
import org.net.eu.pool.mica.{AbstractRuneStorage, ClientExecutor, EmptyRune, EndQuoteRune, HasRegistry, QuoteRune, Rune, RuneShift, ServerExecutor, SidedExecutePacket, registryFor, given}
22
22
import net.minecraft.client.data.{BlockStateModelGenerator, ItemModelGenerator, ItemModels, Model, ModelIds, ModelSupplier}
23
23
import net.minecraft.client.render.item.model.ItemModel
24
-
import net.minecraft.item.{ItemStack, Items}
24
+
import net.minecraft.data.DataWriter
25
+
import net.minecraft.item.{Item, ItemStack, Items}
26
+
import net.minecraft.loot.{LootPool, LootTable}
25
27
import net.minecraft.network.packet.CustomPayload
26
-
import net.minecraft.registry.RegistryWrapper
28
+
import net.minecraft.registry.{RegistryKey, RegistryKeys, RegistryWrapper}
27
29
import net.minecraft.server.network.ServerPlayerEntity
28
30
import net.minecraft.text.Text
31
+
import net.minecraft.util.hit.BlockHitResult
29
32
import net.minecraft.util.math.Direction.Axis
33
+
import net.minecraft.world.World
34
+
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable
30
35
31
36
import java.nio.file.{Files, Path}
32
37
import java.util.Optional
33
-
import java.util.function.Consumer
38
+
import java.util.concurrent.CompletableFuture
39
+
import java.util.function.{BiConsumer, Consumer}
40
+
import scala.annotation.targetName
34
41
import scala.util.chaining.scalaUtilChainingOps
35
42
import scala.collection.convert.ImplicitConversions.given
43
+
import scala.util.boundary.Label
36
44
37
45
def blockAtlas = MinecraftClient.getInstance.getSpriteAtlas(SpriteAtlasTexture.BLOCK_ATLAS_TEXTURE).apply(_)
38
46
···
231
239
obj.add("display", display)
232
240
parent.foreach(i => obj.addProperty("parent", i.toString))
233
241
obj
242
+
243
+
trait EarlyBlockInteractionHandler:
244
+
this: Item =>
245
+
@targetName("mica$earlyUseOnBlock") def earlyUseOnBlock(using ServerPlayerEntity, World, Label[ActionResult])(stack: ItemStack, hand: Hand, hitResult: BlockHitResult): Unit
234
246
235
247
def datagenRune(rune: Rune)(using pack: FabricDataGenerator#Pack) =
236
248
pack.addProvider(
+38
-24
src/main/scala/org/net/eu/pool/mica/AAA_Macros.scala
+38
-24
src/main/scala/org/net/eu/pool/mica/AAA_Macros.scala
···
114
114
115
115
private var registrarState: Option[mutable.Buffer[Expr[Unit]]] = Some(mutable.Buffer.empty)
116
116
117
+
extension (q: Quotes) inline def quote[R](inline body: R): Expr[R] =
118
+
given Quotes = q
119
+
'{ body }
120
+
121
+
trait ConditionallyRegistered(val shouldRegister: Boolean)
122
+
123
+
inline def errorDeferred(msg: String): Nothing = ${errorDeferred_impl('msg)}
124
+
def errorDeferred_impl(msg: Expr[String])(using q: Quotes) =
125
+
q.reflect.report.warning(msg.valueOrError)
126
+
'{ throw IllegalStateException(s"errorDeferred: ${${msg}}") }
127
+
117
128
/**
118
129
* Registers the given value into the best registry for it. This macro may only be applied to `object` literals.
119
130
* @param key Combined with a [[ModID]] in scope to create the value's [[Identifier]]
120
131
*/
121
132
@compileTimeOnly("@register is expanded at compile-time")
122
133
class register(key: String) extends MacroAnnotation:
123
-
override def transform(using q: Quotes)(definition: q.reflect.Definition, companion: Option[q.reflect.Definition]): List[q.reflect.Definition] =
134
+
override inline def transform(using q: Quotes)(definition: q.reflect.Definition, companion: Option[q.reflect.Definition]): List[q.reflect.Definition] =
124
135
import q.reflect.*
125
-
val cl =
126
-
definition match
127
-
case cl@ClassDef(_, _, _, _, _) if cl.symbol.flags.is(Flags.Module) => cl
128
-
case _ =>
129
-
report.error("Only objects may be annotated at this time")
130
-
return List(definition) :++ companion
131
-
cl.symbol.typeRef.asType match
132
-
case '[t] =>
133
-
registrarState match
134
-
case Some(l) =>
135
-
val modid: Expr[ModID] = Expr.summon[ModID]
136
-
.getOrElse:
137
-
report.error(s"No mod ID found in file")
138
-
'{ ModID("unknown") }
139
-
val actualThis: Expr[t] = Ref(cl.symbol.companionModule).asExprOf[t]
140
-
l += '{
141
-
Registry.register(summonInline[Registry[? >: t]], Identifier.of(${modid}.name, ${Expr(key)}), ${actualThis})
142
-
()
143
-
}
144
-
List(ClassDef.copy(cl)(cl.symbol.name, cl.constructor, cl.parents, cl.self, cl.body)) :++ companion
145
-
case None =>
146
-
report.error("Registrations were processed too early")
147
-
List(definition) :++ companion
136
+
definition match
137
+
case cl@ClassDef(_, _, _, _, _) if cl.symbol.flags.is(Flags.Module) =>
138
+
cl.symbol.typeRef.asType match
139
+
case '[t] =>
140
+
registrarState match
141
+
case Some(l) =>
142
+
val modid: Expr[ModID] = Expr.summon[ModID]
143
+
.getOrElse:
144
+
report.error(s"No mod ID found in file")
145
+
'{ ModID("unknown") }
146
+
val actualThis = Ref(cl.symbol.companionModule).asExprOf[t]
147
+
l += '{
148
+
if !${actualThis}.isInstanceOf[ConditionallyRegistered] || ${actualThis}.asInstanceOf[ConditionallyRegistered].shouldRegister then
149
+
Registry.register(
150
+
compiletime.summonFrom:
151
+
case r: Registry[? >: t] => r.asInstanceOf[Registry[t]]
152
+
case _ => errorDeferred(${val s: String = s"Cannot find a registry for ${TypeRepr.of[t].show(using Printer.TypeReprShortCode)}"; Expr(s)})
153
+
, Identifier.of(${modid}.name, ${Expr(key)}), ${actualThis}.asInstanceOf[t])
154
+
()
155
+
}
156
+
List(ClassDef.copy(cl)(cl.symbol.name, cl.constructor, cl.parents, cl.self, cl.body)) :++ companion
157
+
case None =>
158
+
report.error("Registrations were processed too early")
159
+
case _ =>
160
+
report.error("Only objects may be annotated at this time")
161
+
List(definition) :++ companion
148
162
end register
149
163
inline def trySummon[T]: Option[T] = compiletime.summonFrom:
150
164
case x: T => Some(x)
+1
-5
src/main/scala/org/net/eu/pool/mica/Defs.scala
+1
-5
src/main/scala/org/net/eu/pool/mica/Defs.scala
···
15
15
import net.minecraft.util.shape.{VoxelShape, VoxelShapes}
16
16
import net.minecraft.world.World
17
17
import org.net.eu.pool.mica.RevealRune.Frame
18
+
import org.slf4j.{Logger, LoggerFactory}
18
19
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable
19
20
20
21
import scala.annotation.MacroAnnotation
···
342
343
given Codec[AnyRegistryKey] = Identifier.CODEC.dispatch("registry", _.key.getRegistry, RegistryKey.createCodec(_).fieldOf("value").xmap(AnyRegistryKey(_), _.key.asInstanceOf[RegistryKey[Object]]))
343
344
344
345
given [T]: RegistryKey[? <: Registry[T]] = Registries.REGISTRIES.getKey.asInstanceOf[RegistryKey[? <: Registry[T]]]
345
-
346
-
@register("registry_key")
347
-
given ValueType[AnyRegistryKey]:
348
-
override def eq[U: ValueType as v](x: AnyRegistryKey, y: U): Boolean = v.cast[AnyRegistryKey](y).contains(x)
349
-
override def show(x: AnyRegistryKey): Text = Text.translatable(x.key.toTranslationKey(x.key.getRegistry.toShortTranslationKey)).withColor(0x2dccfc)
350
346
351
347
/**
352
348
* Holder object for [[Rune! Rune]] registries and common values of [[Rune.surfaceSprite]].
+48
-17
src/main/scala/org/net/eu/pool/mica/Mica.scala
+48
-17
src/main/scala/org/net/eu/pool/mica/Mica.scala
···
53
53
import scala.compiletime.constValue
54
54
import scala.runtime.ObjectRef
55
55
import scala.util.boundary
56
+
import scala.util.boundary.{Break, Label}
56
57
// ifversion(>=2100, <[[
57
58
import net.minecraft.storage.{ReadView, WriteView}
58
59
import org.ladysnake.cca.api.v3.component.sync.AutoSyncedComponent
···
94
95
import scala.util.chaining.scalaUtilChainingOps
95
96
96
97
private given ModID = ModID("mica")
97
-
given (m: ModID) => Logger = LoggerFactory.getLogger(m.name)
98
98
99
99
/**
100
100
* Current serial Minecraft version. This is solely provided for IDE completion; it is expanded before compile-time by m4.
···
518
518
//throw RuneError(Text.literal("Too many side effects in one cast"))
519
519
???
520
520
def findRunes(start: RuneRef, prev: Set[RuneRef] = Set.empty)(using World): Option[List[(Rune, RuneRef)]] =
521
-
logger.debug(s"findRunes ${start} ${prev}")
521
+
println(s"findRunes ${start} ${prev}")
522
522
if start.isEmpty then
523
523
None
524
524
else
525
525
val neigh = (start.rune.computeNeighbors(using start) -- prev).flatMap(findRunes(_, prev + start)).toSeq
526
526
neigh match
527
527
case Seq() =>
528
-
logger.debug(s"\tfindRunes ${start} ${prev}, neigh = ${neigh} | no more neighbors; stop here.")
528
+
println(s"\tfindRunes ${start} ${prev}, neigh = ${neigh} | no more neighbors; stop here.")
529
529
Some(List((start.rune, start)))
530
530
case Seq(x) =>
531
531
val l = (start.rune, start)::x
532
-
logger.debug(s"\tfindRunes ${start} ${prev}, neigh = ${neigh} | ${l}")
532
+
println(s"\tfindRunes ${start} ${prev}, neigh = ${neigh} | ${l}")
533
533
Some(l)
534
534
case _ =>
535
-
logger.debug(s"\tfindRunes ${start} ${prev}, neigh = ${neigh} | too many neighbors!")
535
+
println(s"\tfindRunes ${start} ${prev}, neigh = ${neigh} | too many neighbors!")
536
536
None
537
-
538
-
given logger: Logger = LoggerFactory.getLogger(given_ModID.name)
539
537
540
538
def parseRunes(runes: List[(Rune, RuneRef)])(using World): List[BoxedRune] =
541
539
runes match
···
1029
1027
try !isDoll catch case _ => true
1030
1028
case _ => true
1031
1029
1030
+
object castedValue:
1031
+
def unapply[T: {ValueType, ClassTag}](x: Any)(using v: ValueType[x.type]): Option[T] = v.cast(x)
1032
+
1032
1033
@register("heal")
1033
1034
object HealTargetRune extends UnaryRune:
1034
1035
register { item.register(); registerFrames() }
···
1058
1059
1059
1060
trait RelocatableRune:
1060
1061
rune: Rune =>
1061
-
def relocate(data: rune.Data): rune.Data
1062
+
def relocate(pos: Vec3d)(data: rune.Data): rune.Data
1063
+
1064
+
extension [T] (f: T => T)
1065
+
def on[U >: T](extractor: PartialFunction[U, T]): U => U =
1066
+
case extractor(x) => f(x)
1067
+
case x => x
1068
+
1069
+
def liftPartial[T, R](f: T => Option[R]): PartialFunction[T, R] =
1070
+
object matcher:
1071
+
def unapply(x: T): Option[R] = f(x)
1072
+
{ case matcher(x) => x }
1073
+
1074
+
extension [T: ValueType] (x: T) def relocateValues(pos: Vec3d) = ???
1062
1075
1063
1076
// @register("relocate")
1064
1077
// object RelocateRune extends UnaryRune:
···
1256
1269
register:
1257
1270
RevealRune.item.register()
1258
1271
1272
+
def tryBoundary[B, R](body: Label[B] ?=> R): Either[B, R] =
1273
+
given lbl: Label[B] = Label()
1274
+
try
1275
+
Right(body)
1276
+
catch
1277
+
case b: boundary.Break[B] if b.label eq lbl => Left(b.value)
1278
+
1279
+
@register("registry_key")
1280
+
given ValueType[AnyRegistryKey]:
1281
+
override def eq[U: ValueType as v](x: AnyRegistryKey, y: U): Boolean = v.cast[AnyRegistryKey](y).contains(x)
1282
+
override def show(x: AnyRegistryKey): Text = Text.translatable(x.key.toTranslationKey(x.key.getRegistry.toShortTranslationKey)).withColor(0x2dccfc)
1283
+
1259
1284
private[mica] object JackBlack:
1260
-
def pickaxe(using ci: CallbackInfoReturnable[ActionResult])(ctx: ItemUsageContext): Unit =
1285
+
def cir2label[R: CallbackInfoReturnable as ci](body: Label[R] ?=> Unit): Unit =
1286
+
tryBoundary[R, Unit](_ ?=> body) match
1287
+
case Left(value) => ci.setReturnValue(value)
1288
+
case Right(value) =>
1289
+
def pickaxe(using Label[ActionResult])(ctx: ItemUsageContext): Unit =
1261
1290
val p = ctx.getHitPos
1262
1291
val q = BlockPos.Mutable((p.x * 4).round.toInt, (p.y * 8).round.toInt, (p.z * 4).round.toInt)
1263
1292
val b = BlockPos.Mutable(p.x, p.y, p.z)
···
1288
1317
ent.addVelocity(h.facing.getDoubleVector.multiply(0.1))
1289
1318
given_World.spawnEntity(ent)
1290
1319
ref.rune = EmptyRune
1291
-
ci.setReturnValue(ActionResult.SUCCESS)
1292
-
def flintAndSTEEL_!!(using ci: CallbackInfoReturnable[ActionResult])(ctx: ItemUsageContext): Unit =
1320
+
boundary.break(ActionResult.SUCCESS)
1321
+
def flintAndSTEEL_!!(using Label[ActionResult])(ctx: ItemUsageContext): Unit =
1293
1322
val p = ctx.getHitPos
1294
1323
val q = BlockPos.Mutable((p.x * 4).round.toInt, (p.y * 8).round.toInt, (p.z * 4).round.toInt)
1295
1324
val b = BlockPos.Mutable(p.x, p.y, p.z)
···
1309
1338
case RuneBeStartinShit(d) =>
1310
1339
boundary:
1311
1340
val runes = findRunes(ref).getOrElse:
1312
-
ci.setReturnValue(ActionResult.FAIL)
1313
1341
given_World.playSound(ctx.getPlayer, p.x, p.y, p.z, SoundEvents.BLOCK_FIRE_EXTINGUISH, SoundCategory.PLAYERS)
1314
1342
ctx.getPlayer.sendMessage(Text.literal("The spark fizzles out."), true)
1315
-
boundary.break()
1316
-
ci.setReturnValue(ActionResult.SUCCESS)
1343
+
boundary.break(ActionResult.FAIL)
1317
1344
try
1318
1345
given_World.playSound(ctx.getPlayer, p.x, p.y, p.z, SoundEvents.ITEM_FLINTANDSTEEL_USE, SoundCategory.PLAYERS)
1319
1346
val boxedRunes = parseRunes(runes)
···
1341
1368
ctx.getPlayer.addStatusEffect(StatusEffectInstance(StatusEffects.BLINDNESS, 15*20))
1342
1369
given_World.playSound(ctx.getPlayer, p.x, p.y, p.z, SoundEvents.BLOCK_FIRE_EXTINGUISH, SoundCategory.PLAYERS)
1343
1370
ctx.getPlayer.sendMessage(Text.literal("The world is falling apart at the seams..."), true)
1371
+
boundary.break(ActionResult.SUCCESS)
1344
1372
case _ =>
1345
1373
1346
1374
lazy val runeProbe: Registrar[Item] =
1347
1375
cursedRegister(Identifier.of("mica", "rune_probe"), Item.Settings()):
1348
1376
new Item(_):
1377
+
override def use(world: World, user: PlayerEntity, hand: Hand): ActionResult =
1378
+
Exception("Use tracer").printStackTrace()
1379
+
super.use(world, user, hand)
1349
1380
override def useOnBlock(ctx: ItemUsageContext): ActionResult =
1350
1381
Exception("Rune stuff #1").printStackTrace()
1351
1382
ctx.getPlayer match
···
1568
1599
register { item.register() }
1569
1600
1570
1601
@register("nyaboom")
1571
-
object ExplosionRune extends BinaryRune:
1602
+
object ExplosionRune extends BinaryRune with ConditionallyRegistered(!FabricLoader.getInstance().isModLoaded("fireblanket")):
1572
1603
override type Arg0 = Vec3d
1573
1604
override type Arg1 = Double
1574
1605
override type Return = BoxedSideEffect
···
1649
1680
try
1650
1681
val config = Path.of("config/mica:extra_classes.txt")
1651
1682
if Files.exists(config) then
1652
-
logger.warn("Ignoring config/mica:extra_classes.txt as it is deprecated. Remove the file to silence this warning.")
1683
+
println("Ignoring config/mica:extra_classes.txt as it is deprecated. Remove the file to silence this warning.")
1653
1684
catch case e => ()
1654
1685
PayloadTypeRegistry.playC2S.register(SidedExecutePacket.id, SidedExecutePacket.codec)
1655
1686
PayloadTypeRegistry.playS2C.register(SidedExecutePacket.id, SidedExecutePacket.codec)
1656
1687
ServerPlayNetworking.registerGlobalReceiver[SidedExecutePacket[ClientExecutor]](SidedExecutePacket.id, (p, ctx) => p.payload(ClientExecutor(ctx.player)))
1657
1688
1658
-
def println(msg: Any): Unit = logger.info(msg.toString)
1689
+
def println(msg: Any)(using m: ModID): Unit = Bootstrap.SYSOUT.println(s"${m.name} → $msg")
+10
-4
src/main/scala/org/net/eu/pool/mica/mixin/FlintAndSteelItemMixin.java
+10
-4
src/main/scala/org/net/eu/pool/mica/mixin/FlintAndSteelItemMixin.java
···
8
8
import org.spongepowered.asm.mixin.injection.At;
9
9
import org.spongepowered.asm.mixin.injection.Inject;
10
10
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
11
+
import scala.runtime.BoxedUnit;
12
+
import scala.util.boundary;
13
+
import scala.util.boundary$;
11
14
12
15
@Mixin(FlintAndSteelItem.class)
13
16
public class FlintAndSteelItemMixin {
14
-
@Inject(method = {"useOnBlock", "method_7884"}, at = @At("HEAD"), cancellable = true)
15
-
void startRunes(ItemUsageContext context, CallbackInfoReturnable<ActionResult> cir) {
16
-
JackBlack$.MODULE$.flintAndSTEEL_$bang$bang(cir, context);
17
-
}
17
+
@Inject(method = {"useOnBlock", "method_7884"}, at = @At("HEAD"), cancellable = true)
18
+
void startRunes(ItemUsageContext context, CallbackInfoReturnable<ActionResult> cir) {
19
+
JackBlack$.MODULE$.cir2label(label -> {
20
+
JackBlack$.MODULE$.flintAndSTEEL_$bang$bang(label, context);
21
+
return BoxedUnit.UNIT;
22
+
}, cir);
23
+
}
18
24
}
+6
-1
src/main/scala/org/net/eu/pool/mica/mixin/ItemMixin.java
+6
-1
src/main/scala/org/net/eu/pool/mica/mixin/ItemMixin.java
···
14
14
import org.spongepowered.asm.mixin.injection.Group;
15
15
import org.spongepowered.asm.mixin.injection.Inject;
16
16
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
17
+
import scala.runtime.BoxedUnit;
18
+
import scala.util.boundary;
17
19
18
20
@Mixin(net.minecraft.item.Item.class)
19
21
public abstract class ItemMixin {
···
22
24
@Inject(method = {"useOnBlock", "method_7884"}, at = @At("HEAD"), cancellable = true, remap = false)
23
25
void useOnBlock(ItemUsageContext context, CallbackInfoReturnable<ActionResult> cir) {
24
26
if (getRegistryEntry().isIn(ItemTags.PICKAXES)) {
25
-
JackBlack$.MODULE$.pickaxe(cir, context);
27
+
JackBlack$.MODULE$.cir2label(label -> {
28
+
JackBlack$.MODULE$.pickaxe(label, context);
29
+
return BoxedUnit.UNIT;
30
+
}, cir);
26
31
}
27
32
}
28
33
}