repo for my hex addons :3
view furnace heat
authored by
PoolloverNathan
and committed by
poolcritter
931c8002
257cd0fd
+88
-29
+1
src/main/resources/hexic.mixins.json
+1
src/main/resources/hexic.mixins.json
+62
-29
src/main/scala/org/eu/net/pool/hexic/Hexic.scala
+62
-29
src/main/scala/org/eu/net/pool/hexic/Hexic.scala
···
56
56
import net.fabricmc.fabric.api.transfer.v1.transaction.{Transaction, TransactionContext}
57
57
import net.fabricmc.loader.api.FabricLoader
58
58
import net.minecraft.Bootstrap
59
+
import net.minecraft.block.entity.AbstractFurnaceBlockEntity
59
60
import net.minecraft.block.{AbstractBlock, Block, BlockRenderType, BlockState, BlockWithEntity, ShapeContext}
60
61
import net.minecraft.command.argument.{EntityArgumentType, NbtElementArgumentType, UuidArgumentType}
61
62
import net.minecraft.command.{CommandException, EntitySelector}
···
93
94
import java.nio.file.{Files, Path, Paths, StandardOpenOption}
94
95
import java.util.{Optional, UUID}
95
96
import java.{lang, util}
97
+
import scala.annotation.meta.getter
96
98
import scala.annotation.unchecked.uncheckedVariance
97
99
import scala.annotation.{elidable, experimental, showAsInfix, tailrec, targetName, unused}
98
100
import scala.collection.{IterableOnceOps, IterableOps}
···
1794
1796
)
1795
1797
setConceptScale[FluidVariant](81000)
1796
1798
setConceptScale[MediaVariant.type](10000)
1799
+
setConceptScale[HeatVariant.type](20)
1797
1800
Patterns.register("moveconcept", se"wawdwawqdewewedqwawdwaw"):
1798
1801
Patterns.mkConstAction(4):
1799
1802
case Seq(isIota[BoxedView.Instance, 3](from), isIota[BoxedView.Instance, 2](into), typ: VariantIota[?], isIota[DoubleIota, 0](count)) =>
1800
1803
Using.resource(Transaction.openOuter()):
1801
1804
case tx@given TransactionContext =>
1802
-
val key = ClassTag(typ.data.getClass).trace("class")
1803
-
val scale = conceptScale(key).trace("scale")
1804
-
val toExtract = (scale * count.getDouble).toLong.trace("toExtract")
1805
+
val key = ClassTag(typ.data.getClass)
1806
+
val scale = conceptScale(key)
1807
+
val toExtract = (scale * count.getDouble).toLong
1805
1808
val extract = from.view.tryExtract(typ.data, toExtract)
1806
1809
if extract < toExtract then
1807
1810
??? // TODO: mishap
···
2318
2321
private given typeOfBlock: InventoryView.Type[OfBlock]:
2319
2322
override def deserialize(data: NbtCompound)(using ServerWorld): Option[OfBlock] =
2320
2323
for
2321
-
case posLong: NbtLong <- Option(data.get("p")).trace("key")
2324
+
case posLong: NbtLong <- Option(data.get("p"))
2322
2325
pos = BlockPos.fromLong(posLong.longValue)
2323
2326
namespace = Option(data.getString("m")).filter(!_.isBlank) getOrElse "minecraft"
2324
2327
path = Option(data.getString("w")).filter(!_.isBlank) getOrElse "overworld"
2325
-
key = RegistryKey.of(RegistryKeys.WORLD, Identifier.of(namespace, path)).trace("key")
2328
+
key = RegistryKey.of(RegistryKeys.WORLD, Identifier.of(namespace, path))
2326
2329
given ServerWorld <- Option(summon[ServerWorld].getServer.getWorld(key))
2327
2330
yield OfBlock(pos)
2328
2331
private given typeOfExactEntity: InventoryView.Type[OfExactEntity]:
···
2355
2358
true
2356
2359
)
2357
2360
else Seq()
2361
+
trait SingleVariantHandler(variant: TransferVariant[?]) extends Handler:
2362
+
override def tryExtract(variant: TransferVariant[?], amount: Long)(using TransactionContext, CastingEnvironment): Long = if variant == this.variant then trySubtract(amount) else 0L
2363
+
override def tryInsert(variant: TransferVariant[?], amount: Long)(using TransactionContext, CastingEnvironment): Long = if variant == this.variant then tryAdd(amount) else 0L
2364
+
override def capacity(variant: TransferVariant[?])(using TransactionContext, CastingEnvironment): Long = if variant == this.variant then cap else 0L
2365
+
def trySubtract(amount: Long)(using TransactionContext, CastingEnvironment): Long
2366
+
def tryAdd(amount: Long)(using TransactionContext, CastingEnvironment): Long
2367
+
def cap(using TransactionContext, CastingEnvironment): Long
2368
+
2358
2369
Events.forBlock.register: (pos, state) =>
2359
2370
summon[ServerWorld].getBlockEntity(pos) match
2360
-
case e: BlockEntityAbstractImpetus => Seq(new Handler {
2371
+
case e: BlockEntityAbstractImpetus => Seq(new SingleVariantHandler(MediaVariant) {
2361
2372
private def mediaCapacity = 9000000000000000000L - e.getMedia
2362
-
override def tryExtract(variant: TransferVariant[?], amount: Long)(using TransactionContext, CastingEnvironment): Long =
2363
-
if variant == MediaVariant then
2364
-
val toExtract = amount min e.getMedia
2365
-
doSnapshot(e.getMedia, e.setMedia)(e.getMedia - toExtract)
2366
-
toExtract
2367
-
else 0L
2368
-
override def tryInsert(variant: TransferVariant[?], amount: Long)(using TransactionContext, CastingEnvironment): Long =
2369
-
if variant == MediaVariant then
2370
-
val toInsert = amount min mediaCapacity
2371
-
doSnapshot(e.getMedia, e.setMedia)(e.getMedia + toInsert)
2372
-
toInsert
2373
-
else 0L
2374
-
override def capacity(variant: TransferVariant[?])(using TransactionContext, CastingEnvironment): Long =
2375
-
if variant == MediaVariant then
2376
-
mediaCapacity
2377
-
else 0L
2373
+
override def trySubtract(amount: Long)(using TransactionContext, CastingEnvironment): Long =
2374
+
val toExtract = amount min e.getMedia
2375
+
doSnapshot(e.getMedia, e.setMedia)(e.getMedia - toExtract)
2376
+
toExtract
2377
+
override def tryAdd(amount: Long)(using TransactionContext, CastingEnvironment): Long =
2378
+
val toInsert = amount min mediaCapacity
2379
+
doSnapshot(e.getMedia, e.setMedia)(e.getMedia + toInsert)
2380
+
toInsert
2381
+
override def cap(using TransactionContext, CastingEnvironment): Long = mediaCapacity
2378
2382
})
2383
+
case _ => Seq()
2384
+
Events.forBlock.register: (pos, state) =>
2385
+
summon[ServerWorld].getBlockEntity(pos) match
2386
+
case e: AbstractFurnaceBlockEntity => Seq(
2387
+
new SingleVariantHandler(HeatVariant):
2388
+
override def trySubtract(amount: Long)(using TransactionContext, CastingEnvironment): Long =
2389
+
val action = (amount min e.burnTime).toInt
2390
+
doSnapshot(e.burnTime, e.burnTime = _)(e.burnTime - action)
2391
+
action
2392
+
override def tryAdd(amount: Long)(using TransactionContext, CastingEnvironment): Long =
2393
+
val action = (amount min cap).toInt
2394
+
doSnapshot(e.burnTime, e.burnTime = _)(e.burnTime + action)
2395
+
doSnapshot(e.fuelTime, e.fuelTime = _)(e.fuelTime max e.burnTime)
2396
+
action
2397
+
override def cap(using TransactionContext, CastingEnvironment): Long = (5*60*20) - e.burnTime
2398
+
)
2399
+
case _ => Seq()
2400
+
given Conversion[AbstractFurnaceBlockEntity, AbstractFurnaceBlockEntityAccess] = _.asInstanceOf // by mixin
2401
+
trait AbstractFurnaceBlockEntityAccess:
2402
+
def burnTime: Int
2403
+
def burnTime_=(burnTime: Int): Unit
2404
+
def fuelTime: Int
2405
+
def fuelTime_=(fuelTime: Int): Unit
2379
2406
2380
2407
def doSnapshot[T](current: => T, apply: T => Unit)(toApply: T)(using tx: TransactionContext): Unit =
2381
2408
object partip extends SnapshotParticipant[T]:
···
2563
2590
Some(x)
2564
2591
2565
2592
//noinspection UnstableApiUsage
2566
-
object MediaVariant extends TransferVariant[MediaVariant.type]:
2593
+
class NoDataVariant extends TransferVariant[NoDataVariant]:
2567
2594
def getNbt = NbtCompound()
2568
-
def getObject: MediaVariant.type = MediaVariant
2595
+
def getObject: this.type = this
2569
2596
def isBlank = false
2570
2597
def toNbt = NbtCompound()
2571
2598
def toPacket(buf: net.minecraft.network.PacketByteBuf): Unit = ()
2599
+
object MediaVariant extends NoDataVariant
2600
+
object HeatVariant extends NoDataVariant
2601
+
object EnergyVariant extends NoDataVariant
2572
2602
2573
2603
trait FromIota[T]:
2574
2604
def convert(iota: Iota): Option[T]
···
2975
3005
type T = Fluid
2976
3006
def variant: TransferVariant[Fluid] = s
2977
3007
def display: MutableText = t"${s.getFluid.getDefaultState.getBlockState.getBlock.getName}: ${ItemInlineData.make(s.getFluid.getBucketItem.getDefaultStack)}"
2978
-
registry("media") = c =>
2979
-
Some(new TaggedVariant:
2980
-
type T = MediaVariant.type
2981
-
def variant: MediaVariant.type = MediaVariant
2982
-
def display: Text = Text.literal("Media").styled(_.withColor(0x74b3f2)))
3008
+
def singleton(x: NoDataVariant, disp: Text): NbtCompound => Some[TaggedVariant] =
3009
+
val ret = Some(new TaggedVariant:
3010
+
type T = NoDataVariant
3011
+
def variant: x.type = x
3012
+
def display: Text = disp)
3013
+
_ => ret
3014
+
registry("media") = singleton(MediaVariant, Text.literal("Media").styled(_.withColor(0x74b3f2)))
3015
+
registry("heat") = singleton(HeatVariant, Text.literal("Heat").styled(_.withColor(0xe08355)))
2983
3016
2984
3017
object registerHopperEndpoint extends (() => Unit):
2985
3018
def apply(): Unit =
+25
src/main/scala/org/eu/net/pool/hexic/mixin/AbstractFurnaceBlockEntityMixin.java
+25
src/main/scala/org/eu/net/pool/hexic/mixin/AbstractFurnaceBlockEntityMixin.java
···
1
+
package org.eu.net.pool.hexic.mixin;
2
+
3
+
import net.minecraft.block.entity.AbstractFurnaceBlockEntity;
4
+
import org.eu.net.pool.hexic.AbstractFurnaceBlockEntityAccess;
5
+
import org.spongepowered.asm.mixin.Mixin;
6
+
import org.spongepowered.asm.mixin.gen.Accessor;
7
+
8
+
@Mixin(AbstractFurnaceBlockEntity.class)
9
+
public abstract class AbstractFurnaceBlockEntityMixin implements AbstractFurnaceBlockEntityAccess {
10
+
@Override
11
+
@Accessor("burnTime")
12
+
public abstract int burnTime();
13
+
14
+
@Override
15
+
@Accessor("burnTime")
16
+
public abstract void burnTime_$eq(int burnTime);
17
+
18
+
@Override
19
+
@Accessor("fuelTime")
20
+
public abstract int fuelTime();
21
+
22
+
@Override
23
+
@Accessor("fuelTime")
24
+
public abstract void fuelTime_$eq(int fuelTime);
25
+
}