repo for my hex addons :3
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

view furnace heat

authored by

PoolloverNathan and committed by
poolcritter
931c8002 257cd0fd

+88 -29
+1
src/main/resources/hexic.mixins.json
··· 4 4 "package": "org.eu.net.pool.hexic.mixin", 5 5 "compatibilityLevel": "JAVA_17", 6 6 "mixins": [ 7 + "AbstractFurnaceBlockEntityMixin", 7 8 "ActionRegistryEntryMixin", 8 9 "BiomeMixin", 9 10 "CastingVMMixin",
+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
··· 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 + }