From 8c13fc22dc775f76671dfcbadc42c64ae70f445a Mon Sep 17 00:00:00 2001 From: "yrsegal@gmail.com" Date: Tue, 16 Aug 2022 22:11:51 -0400 Subject: [PATCH 1/8] media can now be drawn from trinkets, armor, and offhand also, armor can no longer keep you safe from the subsuming of your mind --- .../api/misc/DiscoveryHandlers.java | 42 +++++++++++++ .../api/spell/casting/CastingHarness.kt | 42 +++++++++---- .../hexcasting/api/spell/mishaps/Mishap.kt | 22 ++++++- .../petrak/hexcasting/api/utils/ManaHelper.kt | 37 ++++++++---- .../client/HexAdditionalRenderers.java | 4 +- .../casting/operators/spells/OpExplode.kt | 2 +- .../hexcasting/common/items/ItemLens.java | 27 ++------- .../items/magic/DebugUnlockerHolder.java | 57 ++++++++++++++++++ .../items/magic/ItemCreativeUnlocker.java | 31 +++++++++- .../hexcasting/ktxt/AccessorWrappers.kt | 15 +++++ .../mixin/accessor/AccessorEntity.java | 11 ++++ .../mixin/accessor/AccessorLivingEntity.java | 21 +++++++ Common/src/main/resources/hexplat.mixins.json | 1 + .../interop/trinkets/TrinketsApiInterop.java | 36 ++++++++++- .../interop/curios/CuriosApiInterop.java | 60 ++++++++++++++++++- 15 files changed, 353 insertions(+), 55 deletions(-) create mode 100644 Common/src/main/java/at/petrak/hexcasting/api/misc/DiscoveryHandlers.java create mode 100644 Common/src/main/java/at/petrak/hexcasting/common/items/magic/DebugUnlockerHolder.java create mode 100644 Common/src/main/java/at/petrak/hexcasting/mixin/accessor/AccessorEntity.java diff --git a/Common/src/main/java/at/petrak/hexcasting/api/misc/DiscoveryHandlers.java b/Common/src/main/java/at/petrak/hexcasting/api/misc/DiscoveryHandlers.java new file mode 100644 index 00000000..e9f04fb6 --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/api/misc/DiscoveryHandlers.java @@ -0,0 +1,42 @@ +package at.petrak.hexcasting.api.misc; + +import at.petrak.hexcasting.api.addldata.ManaHolder; +import at.petrak.hexcasting.api.spell.casting.CastingHarness; +import com.google.common.collect.Lists; +import net.minecraft.world.entity.player.Player; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.Function; +import java.util.function.Predicate; + +public class DiscoveryHandlers { + private static final List> HAS_LENS_PREDICATE = new ArrayList<>(); + private static final List>> MANA_HOLDER_DISCOVERY = new ArrayList<>(); + + public static boolean hasLens(Player player) { + for (var predicate : HAS_LENS_PREDICATE) { + if (predicate.test(player)) { + return true; + } + } + return false; + } + + public static List collectManaHolders(CastingHarness harness) { + List holders = Lists.newArrayList(); + for (var discoverer : MANA_HOLDER_DISCOVERY) { + holders.addAll(discoverer.apply(harness)); + } + return holders; + } + + + public static void addLensPredicate(Predicate predicate) { + HAS_LENS_PREDICATE.add(predicate); + } + + public static void addManaHolderDiscoverer(Function> discoverer) { + MANA_HOLDER_DISCOVERY.add(discoverer); + } +} diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingHarness.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingHarness.kt index 37ea6227..1e88d402 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingHarness.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingHarness.kt @@ -3,6 +3,7 @@ package at.petrak.hexcasting.api.spell.casting import at.petrak.hexcasting.api.PatternRegistry import at.petrak.hexcasting.api.advancements.HexAdvancementTriggers import at.petrak.hexcasting.api.block.circle.BlockEntityAbstractImpetus +import at.petrak.hexcasting.api.misc.DiscoveryHandlers import at.petrak.hexcasting.api.misc.FrozenColorizer import at.petrak.hexcasting.api.misc.HexDamageSources import at.petrak.hexcasting.api.mod.HexConfig @@ -13,7 +14,6 @@ import at.petrak.hexcasting.api.spell.math.HexDir import at.petrak.hexcasting.api.spell.math.HexPattern import at.petrak.hexcasting.api.spell.mishaps.* import at.petrak.hexcasting.api.utils.* -import at.petrak.hexcasting.common.items.magic.ItemCreativeUnlocker import at.petrak.hexcasting.xplat.IXplatAbstractions import net.minecraft.nbt.CompoundTag import net.minecraft.nbt.Tag @@ -404,12 +404,12 @@ class CastingHarness private constructor( } else { false } + if (casterStack.`is`(HexItemTags.WANDS) || hexHolderDrawsFromInventory) { - val manableItems = this.ctx.caster.inventory.items - .filter(::isManaItem) + val manaSources = DiscoveryHandlers.collectManaHolders(this) .sortedWith(Comparator(::compareManaItem).reversed()) - for (stack in manableItems) { - costLeft -= extractMana(stack, costLeft, simulate = fake && !ItemCreativeUnlocker.isDebug(stack)) + for (source in manaSources) { + costLeft -= extractMana(source, costLeft, simulate = fake) if (costLeft <= 0) break } @@ -421,13 +421,17 @@ class CastingHarness private constructor( val manaAbleToCastFromHP = this.ctx.caster.health * manaToHealth val manaToActuallyPayFor = min(manaAbleToCastFromHP.toInt(), costLeft) - if (!fake) { - HexAdvancementTriggers.OVERCAST_TRIGGER.trigger(this.ctx.caster, manaToActuallyPayFor) - this.ctx.caster.awardStat(HexStatistics.MANA_OVERCASTED, manaCost - costLeft) - + costLeft -= if (!fake) { Mishap.trulyHurt(this.ctx.caster, HexDamageSources.OVERCAST, healthtoRemove.toFloat()) + + val actuallyTaken = (manaAbleToCastFromHP - (this.ctx.caster.health * manaToHealth)).toInt() + + HexAdvancementTriggers.OVERCAST_TRIGGER.trigger(this.ctx.caster, actuallyTaken) + this.ctx.caster.awardStat(HexStatistics.MANA_OVERCASTED, manaCost - costLeft) + actuallyTaken + } else { + manaToActuallyPayFor } - costLeft -= manaToActuallyPayFor } } } @@ -475,6 +479,24 @@ class CastingHarness private constructor( const val TAG_ESCAPE_NEXT = "escape_next" const val TAG_PREPACKAGED_COLORIZER = "prepackaged_colorizer" + init { + DiscoveryHandlers.addManaHolderDiscoverer { + it.ctx.caster.inventory.items + .filter(::isManaItem) + .mapNotNull(IXplatAbstractions.INSTANCE::findManaHolder) + } + DiscoveryHandlers.addManaHolderDiscoverer { + it.ctx.caster.armorSlots + .filter(::isManaItem) + .mapNotNull(IXplatAbstractions.INSTANCE::findManaHolder) + } + DiscoveryHandlers.addManaHolderDiscoverer { + listOf(it.ctx.caster.offhandItem) + .filter(::isManaItem) + .mapNotNull(IXplatAbstractions.INSTANCE::findManaHolder) + } + } + @JvmStatic fun fromNBT(nbt: CompoundTag, ctx: CastingContext): CastingHarness { return try { diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/Mishap.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/Mishap.kt index da61d73f..41a3a588 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/Mishap.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/Mishap.kt @@ -10,7 +10,7 @@ import at.petrak.hexcasting.api.spell.math.HexPattern import at.petrak.hexcasting.api.utils.asTranslatedComponent import at.petrak.hexcasting.api.utils.lightPurple import at.petrak.hexcasting.common.lib.HexItems -import at.petrak.hexcasting.ktxt.lastHurt +import at.petrak.hexcasting.ktxt.* import net.minecraft.Util import net.minecraft.core.BlockPos import net.minecraft.network.chat.Component @@ -109,7 +109,25 @@ sealed class Mishap : Throwable() { else entity.lastHurt -= amount } - entity.hurt(source, amount) + if (!entity.hurt(source, amount)) { + // Ok, if you REALLY don't want to play nice... + entity.health -= amount + entity.markHurt() + + if (entity.isDeadOrDying) { + if (!entity.checkTotemDeathProtection(source)) { + val sound = entity.deathSoundAccessor + if (sound != null) { + entity.playSound(sound, entity.soundVolumeAccessor, entity.voicePitch) + } + entity.die(source) + } + } else { + entity.playHurtSound(source) + } + + entity.setHurtWithStamp(source, entity.level.gameTime) + } } } } diff --git a/Common/src/main/java/at/petrak/hexcasting/api/utils/ManaHelper.kt b/Common/src/main/java/at/petrak/hexcasting/api/utils/ManaHelper.kt index 239e3a25..fe020dfd 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/utils/ManaHelper.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/utils/ManaHelper.kt @@ -1,6 +1,7 @@ @file:JvmName("ManaHelper") package at.petrak.hexcasting.api.utils +import at.petrak.hexcasting.api.addldata.ManaHolder import at.petrak.hexcasting.xplat.IXplatAbstractions import net.minecraft.util.Mth import net.minecraft.world.item.ItemStack @@ -30,26 +31,38 @@ fun extractMana( ): Int { val manaHolder = IXplatAbstractions.INSTANCE.findManaHolder(stack) ?: return 0 - if (drainForBatteries && !manaHolder.canConstructBattery()) + return extractMana(manaHolder, cost, drainForBatteries, simulate) +} + +/** + * Extract [cost] mana from [holder]. If [cost] is less than zero, extract all mana instead. + * This may mutate the stack underlying [holder] (and may consume it) unless [simulate] is set. + * + * If [drainForBatteries] is false, this will only consider forms of mana that can be used to make new batteries. + * + * Return the amount of mana extracted. This may be over [cost] if mana is wasted. + */ +fun extractMana( + holder: ManaHolder, + cost: Int = -1, + drainForBatteries: Boolean = false, + simulate: Boolean = false +): Int { + if (drainForBatteries && !holder.canConstructBattery()) return 0 - return manaHolder.withdrawMana(cost, simulate) + return holder.withdrawMana(cost, simulate) } /** * Sorted from least important to most important */ -fun compareManaItem(astack: ItemStack, bstack: ItemStack): Int { - val aMana = IXplatAbstractions.INSTANCE.findManaHolder(astack) - val bMana = IXplatAbstractions.INSTANCE.findManaHolder(bstack) +fun compareManaItem(aMana: ManaHolder, bMana: ManaHolder): Int { + val priority = aMana.consumptionPriority - bMana.consumptionPriority + if (priority != 0) + return priority - return if (astack.item != bstack.item) { - (aMana?.consumptionPriority ?: 0) - (bMana?.consumptionPriority ?: 0) - } else if (aMana != null && bMana != null) { - aMana.mana - bMana.mana - } else { - astack.count - bstack.count - } + return aMana.mana - bMana.mana } fun manaBarColor(mana: Int, maxMana: Int): Int { diff --git a/Common/src/main/java/at/petrak/hexcasting/client/HexAdditionalRenderers.java b/Common/src/main/java/at/petrak/hexcasting/client/HexAdditionalRenderers.java index c7c70932..7817e966 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/HexAdditionalRenderers.java +++ b/Common/src/main/java/at/petrak/hexcasting/client/HexAdditionalRenderers.java @@ -1,8 +1,8 @@ package at.petrak.hexcasting.client; import at.petrak.hexcasting.api.client.ScryingLensOverlayRegistry; +import at.petrak.hexcasting.api.misc.DiscoveryHandlers; import at.petrak.hexcasting.api.player.Sentinel; -import at.petrak.hexcasting.common.items.ItemLens; import at.petrak.hexcasting.xplat.IXplatAbstractions; import com.google.common.collect.Lists; import com.mojang.blaze3d.platform.GlStateManager; @@ -155,7 +155,7 @@ public class HexAdditionalRenderers { return; } - if (!ItemLens.hasLensHUD(player)) + if (!DiscoveryHandlers.hasLens(player)) return; var hitRes = mc.hitResult; diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpExplode.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpExplode.kt index 37efc873..243f506d 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpExplode.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpExplode.kt @@ -20,7 +20,7 @@ class OpExplode(val fire: Boolean) : SpellOperator { val strength = args.getChecked(1, argc) ctx.assertVecInRange(pos) val clampedStrength = Mth.clamp(strength, 0.0, 10.0) - val cost = ManaConstants.DUST_UNIT * (3 * clampedStrength + if (fire) 0.125 else 1.0) + val cost = ManaConstants.DUST_UNIT * (3 * clampedStrength + if (fire) 1.0 else 0.125) return Triple( Spell(pos, clampedStrength, this.fire), cost.toInt(), diff --git a/Common/src/main/java/at/petrak/hexcasting/common/items/ItemLens.java b/Common/src/main/java/at/petrak/hexcasting/common/items/ItemLens.java index 9bc36f03..e370cb48 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/items/ItemLens.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/items/ItemLens.java @@ -1,6 +1,7 @@ package at.petrak.hexcasting.common.items; import at.petrak.hexcasting.annotations.SoftImplement; +import at.petrak.hexcasting.api.misc.DiscoveryHandlers; import at.petrak.hexcasting.common.lib.HexItems; import at.petrak.hexcasting.common.network.MsgUpdateComparatorVisualsAck; import at.petrak.hexcasting.xplat.IXplatAbstractions; @@ -14,7 +15,6 @@ import net.minecraft.sounds.SoundEvent; import net.minecraft.sounds.SoundEvents; import net.minecraft.world.entity.Entity; import net.minecraft.world.entity.EquipmentSlot; -import net.minecraft.world.entity.player.Player; import net.minecraft.world.item.ArmorItem; import net.minecraft.world.item.Item; import net.minecraft.world.item.ItemStack; @@ -29,32 +29,15 @@ import net.minecraft.world.phys.HitResult; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.ArrayList; -import java.util.List; import java.util.Map; import java.util.WeakHashMap; -import java.util.function.Predicate; public class ItemLens extends Item implements Wearable { - private static final List> HAS_HUD_PREDICATE = new ArrayList<>(); static { - addLensHUDPredicate(player -> player.getItemBySlot(EquipmentSlot.MAINHAND).is(HexItems.SCRYING_LENS)); - addLensHUDPredicate(player -> player.getItemBySlot(EquipmentSlot.OFFHAND).is(HexItems.SCRYING_LENS)); - addLensHUDPredicate(player -> player.getItemBySlot(EquipmentSlot.HEAD).is(HexItems.SCRYING_LENS)); - } - - public static boolean hasLensHUD(Player player) { - for (Predicate predicate : HAS_HUD_PREDICATE) { - if (predicate.test(player)) { - return true; - } - } - return false; - } - - public static void addLensHUDPredicate(Predicate predicate) { - HAS_HUD_PREDICATE.add(predicate); + DiscoveryHandlers.addLensPredicate(player -> player.getItemBySlot(EquipmentSlot.MAINHAND).is(HexItems.SCRYING_LENS)); + DiscoveryHandlers.addLensPredicate(player -> player.getItemBySlot(EquipmentSlot.OFFHAND).is(HexItems.SCRYING_LENS)); + DiscoveryHandlers.addLensPredicate(player -> player.getItemBySlot(EquipmentSlot.HEAD).is(HexItems.SCRYING_LENS)); } public ItemLens(Properties pProperties) { @@ -82,7 +65,7 @@ public class ItemLens extends Item implements Wearable { } public static void tickLens(Entity pEntity) { - if (!pEntity.getLevel().isClientSide() && pEntity instanceof ServerPlayer player && hasLensHUD(player)) { + if (!pEntity.getLevel().isClientSide() && pEntity instanceof ServerPlayer player && DiscoveryHandlers.hasLens(player)) { sendComparatorDataToClient(player); } } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/items/magic/DebugUnlockerHolder.java b/Common/src/main/java/at/petrak/hexcasting/common/items/magic/DebugUnlockerHolder.java new file mode 100644 index 00000000..b6e65fe3 --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/common/items/magic/DebugUnlockerHolder.java @@ -0,0 +1,57 @@ +package at.petrak.hexcasting.common.items.magic; + +import at.petrak.hexcasting.api.addldata.ManaHolder; +import at.petrak.hexcasting.api.utils.NBTHelper; +import net.minecraft.world.item.ItemStack; + +import java.util.Arrays; + +public record DebugUnlockerHolder(ItemStack creativeUnlocker) implements ManaHolder { + @Override + public int getMana() { + return Integer.MAX_VALUE; + } + + @Override + public int getMaxMana() { + return Integer.MAX_VALUE - 1; + } + + @Override + public void setMana(int mana) { + // NO-OP + } + + @Override + public boolean canRecharge() { + return false; + } + + @Override + public boolean canProvide() { + return true; + } + + @Override + public int getConsumptionPriority() { + return 1000; + } + + @Override + public boolean canConstructBattery() { + return false; + } + + @Override + public int withdrawMana(int cost, boolean simulate) { + int[] arr = NBTHelper.getIntArray(creativeUnlocker, ItemCreativeUnlocker.TAG_EXTRACTIONS); + if (arr == null) { + arr = new int[0]; + } + int[] newArr = Arrays.copyOf(arr, arr.length + 1); + newArr[newArr.length - 1] = cost; + NBTHelper.putIntArray(creativeUnlocker, ItemCreativeUnlocker.TAG_EXTRACTIONS, newArr); + + return cost < 0 ? 1 : cost; + } +} diff --git a/Common/src/main/java/at/petrak/hexcasting/common/items/magic/ItemCreativeUnlocker.java b/Common/src/main/java/at/petrak/hexcasting/common/items/magic/ItemCreativeUnlocker.java index 7232871b..8c92a21d 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/items/magic/ItemCreativeUnlocker.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/items/magic/ItemCreativeUnlocker.java @@ -1,6 +1,7 @@ package at.petrak.hexcasting.common.items.magic; import at.petrak.hexcasting.api.item.ManaHolderItem; +import at.petrak.hexcasting.api.misc.DiscoveryHandlers; import at.petrak.hexcasting.api.misc.ManaConstants; import at.petrak.hexcasting.api.utils.NBTHelper; import at.petrak.hexcasting.common.lib.HexItems; @@ -29,6 +30,33 @@ import static at.petrak.hexcasting.api.HexAPI.modLoc; public class ItemCreativeUnlocker extends Item implements ManaHolderItem { + static { + DiscoveryHandlers.addManaHolderDiscoverer(harness -> { + var player = harness.getCtx().getCaster(); + if (!player.isCreative()) + return List.of(); + + for (ItemStack item : player.inventoryMenu.getItems()) { + if (isDebug(item)) { + return List.of(new DebugUnlockerHolder(item)); + } + } + + // Technically possible with commands! + for (ItemStack item : player.getArmorSlots()) { + if (isDebug(item)) { + return List.of(new DebugUnlockerHolder(item)); + } + } + + if (isDebug(player.getOffhandItem())) { + return List.of(new DebugUnlockerHolder(player.getOffhandItem())); + } + + return List.of(); + }); + } + public static boolean isDebug(ItemStack stack) { return stack.is(HexItems.CREATIVE_UNLOCKER) && stack.hasCustomHoverName() @@ -47,7 +75,7 @@ public class ItemCreativeUnlocker extends Item implements ManaHolderItem { return emphasized; } - private static final String TAG_EXTRACTIONS = "extractions"; + public static final String TAG_EXTRACTIONS = "extractions"; public ItemCreativeUnlocker(Properties properties) { super(properties); @@ -80,6 +108,7 @@ public class ItemCreativeUnlocker extends Item implements ManaHolderItem { @Override public int withdrawMana(ItemStack stack, int cost, boolean simulate) { + // In case it's withdrawn through other means if (!simulate && isDebug(stack)) { int[] arr = NBTHelper.getIntArray(stack, TAG_EXTRACTIONS); if (arr == null) { diff --git a/Common/src/main/java/at/petrak/hexcasting/ktxt/AccessorWrappers.kt b/Common/src/main/java/at/petrak/hexcasting/ktxt/AccessorWrappers.kt index f6aa7d44..c1465319 100644 --- a/Common/src/main/java/at/petrak/hexcasting/ktxt/AccessorWrappers.kt +++ b/Common/src/main/java/at/petrak/hexcasting/ktxt/AccessorWrappers.kt @@ -1,10 +1,13 @@ @file:JvmName("AccessorWrappers") package at.petrak.hexcasting.ktxt +import at.petrak.hexcasting.mixin.accessor.AccessorEntity import at.petrak.hexcasting.mixin.accessor.AccessorLivingEntity import at.petrak.hexcasting.mixin.accessor.AccessorUseOnContext import at.petrak.hexcasting.mixin.accessor.AccessorVillager +import net.minecraft.sounds.SoundEvent import net.minecraft.world.InteractionHand +import net.minecraft.world.damagesource.DamageSource import net.minecraft.world.entity.Entity import net.minecraft.world.entity.LivingEntity import net.minecraft.world.entity.npc.Villager @@ -18,6 +21,18 @@ var LivingEntity.lastHurt: Float get() = (this as AccessorLivingEntity).`hex$getLastHurt`() set(value) = (this as AccessorLivingEntity).`hex$setLastHurt`(value) +fun LivingEntity.playHurtSound(source: DamageSource) = (this as AccessorLivingEntity).`hex$playHurtSound`(source) +fun LivingEntity.checkTotemDeathProtection(source: DamageSource) = (this as AccessorLivingEntity).`hex$checkTotemDeathProtection`(source) +val LivingEntity.deathSoundAccessor: SoundEvent? get() = (this as AccessorLivingEntity).`hex$getDeathSound`() +val LivingEntity.soundVolumeAccessor get() = (this as AccessorLivingEntity).`hex$getSoundVolume`() + +fun LivingEntity.setHurtWithStamp(source: DamageSource, stamp: Long) = (this as AccessorLivingEntity).apply { + `hex$setLastDamageSource`(source) + `hex$setLastDamageStamp`(stamp) +} + +fun Entity.markHurt() = (this as AccessorEntity).`hex$markHurt`() + fun Villager.tellWitnessesThatIWasMurdered(murderer: Entity) = (this as AccessorVillager).`hex$tellWitnessesThatIWasMurdered`(murderer) @Suppress("FunctionName") diff --git a/Common/src/main/java/at/petrak/hexcasting/mixin/accessor/AccessorEntity.java b/Common/src/main/java/at/petrak/hexcasting/mixin/accessor/AccessorEntity.java new file mode 100644 index 00000000..69166985 --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/mixin/accessor/AccessorEntity.java @@ -0,0 +1,11 @@ +package at.petrak.hexcasting.mixin.accessor; + +import net.minecraft.world.entity.Entity; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.gen.Invoker; + +@Mixin(Entity.class) +public interface AccessorEntity { + @Invoker("markHurt") + void hex$markHurt(); +} diff --git a/Common/src/main/java/at/petrak/hexcasting/mixin/accessor/AccessorLivingEntity.java b/Common/src/main/java/at/petrak/hexcasting/mixin/accessor/AccessorLivingEntity.java index 21608dea..fde107fc 100644 --- a/Common/src/main/java/at/petrak/hexcasting/mixin/accessor/AccessorLivingEntity.java +++ b/Common/src/main/java/at/petrak/hexcasting/mixin/accessor/AccessorLivingEntity.java @@ -1,8 +1,11 @@ package at.petrak.hexcasting.mixin.accessor; +import net.minecraft.sounds.SoundEvent; +import net.minecraft.world.damagesource.DamageSource; import net.minecraft.world.entity.LivingEntity; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.gen.Accessor; +import org.spongepowered.asm.mixin.gen.Invoker; @Mixin(LivingEntity.class) public interface AccessorLivingEntity { @@ -11,4 +14,22 @@ public interface AccessorLivingEntity { @Accessor("lastHurt") void hex$setLastHurt(float lastHurt); + + @Invoker("playHurtSound") + void hex$playHurtSound(DamageSource source); + + @Invoker("checkTotemDeathProtection") + boolean hex$checkTotemDeathProtection(DamageSource source); + + @Invoker("getDeathSound") + SoundEvent hex$getDeathSound(); + + @Invoker("getSoundVolume") + float hex$getSoundVolume(); + + @Accessor("lastDamageSource") + void hex$setLastDamageSource(DamageSource source); + + @Accessor("lastDamageStamp") + void hex$setLastDamageStamp(long stamp); } diff --git a/Common/src/main/resources/hexplat.mixins.json b/Common/src/main/resources/hexplat.mixins.json index d0cc4b1c..8161726b 100644 --- a/Common/src/main/resources/hexplat.mixins.json +++ b/Common/src/main/resources/hexplat.mixins.json @@ -11,6 +11,7 @@ "MixinReloadableServerResources", "MixinVillager", "MixinWitch", + "accessor.AccessorEntity", "accessor.AccessorLivingEntity", "accessor.AccessorLootTable", "accessor.AccessorPoiType", diff --git a/Fabric/src/main/java/at/petrak/hexcasting/fabric/interop/trinkets/TrinketsApiInterop.java b/Fabric/src/main/java/at/petrak/hexcasting/fabric/interop/trinkets/TrinketsApiInterop.java index a6187d08..de184b2a 100644 --- a/Fabric/src/main/java/at/petrak/hexcasting/fabric/interop/trinkets/TrinketsApiInterop.java +++ b/Fabric/src/main/java/at/petrak/hexcasting/fabric/interop/trinkets/TrinketsApiInterop.java @@ -1,18 +1,25 @@ package at.petrak.hexcasting.fabric.interop.trinkets; -import at.petrak.hexcasting.common.items.ItemLens; +import at.petrak.hexcasting.api.misc.DiscoveryHandlers; +import at.petrak.hexcasting.api.utils.ManaHelper; +import at.petrak.hexcasting.common.items.magic.DebugUnlockerHolder; +import at.petrak.hexcasting.common.items.magic.ItemCreativeUnlocker; import at.petrak.hexcasting.common.lib.HexItems; +import at.petrak.hexcasting.xplat.IXplatAbstractions; import dev.emi.trinkets.api.TrinketComponent; import dev.emi.trinkets.api.TrinketsApi; import dev.emi.trinkets.api.client.TrinketRendererRegistry; import net.fabricmc.api.EnvType; import net.fabricmc.api.Environment; +import net.minecraft.util.Tuple; +import java.util.List; +import java.util.Objects; import java.util.Optional; public class TrinketsApiInterop { public static void init() { - ItemLens.addLensHUDPredicate(player -> { + DiscoveryHandlers.addLensPredicate(player -> { Optional optional = TrinketsApi.getTrinketComponent(player); if (optional.isPresent()) { TrinketComponent component = optional.get(); @@ -20,6 +27,31 @@ public class TrinketsApiInterop { } return false; }); + + DiscoveryHandlers.addManaHolderDiscoverer(harness -> { + Optional optional = TrinketsApi.getTrinketComponent(harness.getCtx().getCaster()); + if (optional.isPresent()) { + TrinketComponent component = optional.get(); + return component.getEquipped(ManaHelper::isManaItem).stream() + .map(Tuple::getB) + .map(IXplatAbstractions.INSTANCE::findManaHolder) + .filter(Objects::nonNull) + .toList(); + } + return List.of(); + }); + + DiscoveryHandlers.addManaHolderDiscoverer(harness -> { + Optional optional = TrinketsApi.getTrinketComponent(harness.getCtx().getCaster()); + if (optional.isPresent()) { + TrinketComponent component = optional.get(); + var equipped = component.getEquipped(ItemCreativeUnlocker::isDebug); + if (!equipped.isEmpty()) { + return List.of(new DebugUnlockerHolder(equipped.get(0).getB())); + } + } + return List.of(); + }); } @Environment(EnvType.CLIENT) diff --git a/Forge/src/main/java/at/petrak/hexcasting/forge/interop/curios/CuriosApiInterop.java b/Forge/src/main/java/at/petrak/hexcasting/forge/interop/curios/CuriosApiInterop.java index 2f3ebcd7..f90fa3f2 100644 --- a/Forge/src/main/java/at/petrak/hexcasting/forge/interop/curios/CuriosApiInterop.java +++ b/Forge/src/main/java/at/petrak/hexcasting/forge/interop/curios/CuriosApiInterop.java @@ -1,8 +1,14 @@ package at.petrak.hexcasting.forge.interop.curios; -import at.petrak.hexcasting.common.items.ItemLens; +import at.petrak.hexcasting.api.addldata.ManaHolder; +import at.petrak.hexcasting.api.misc.DiscoveryHandlers; +import at.petrak.hexcasting.api.utils.ManaHelper; +import at.petrak.hexcasting.common.items.magic.DebugUnlockerHolder; +import at.petrak.hexcasting.common.items.magic.ItemCreativeUnlocker; import at.petrak.hexcasting.common.lib.HexItems; import at.petrak.hexcasting.interop.HexInterop; +import at.petrak.hexcasting.xplat.IXplatAbstractions; +import com.google.common.collect.Lists; import net.minecraftforge.fml.InterModComms; import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent; import net.minecraftforge.fml.event.lifecycle.InterModEnqueueEvent; @@ -11,19 +17,67 @@ import top.theillusivec4.curios.api.SlotTypeMessage; import top.theillusivec4.curios.api.SlotTypePreset; import top.theillusivec4.curios.api.type.inventory.ICurioStacksHandler; +import java.util.List; import java.util.concurrent.atomic.AtomicBoolean; public class CuriosApiInterop { public static void init() { - ItemLens.addLensHUDPredicate(player -> { + DiscoveryHandlers.addLensPredicate(player -> { AtomicBoolean hasLens = new AtomicBoolean(false); player.getCapability(CuriosCapability.INVENTORY).ifPresent(handler -> { ICurioStacksHandler stacksHandler = handler.getCurios().get("head"); - if(stacksHandler != null) hasLens.set(stacksHandler.getStacks().getStackInSlot(0).is(HexItems.SCRYING_LENS)); + if(stacksHandler != null) { + var stacks = stacksHandler.getStacks(); + for (int i = 0; i < stacks.getSlots(); i++) { + if (stacks.getStackInSlot(i).is(HexItems.SCRYING_LENS)) { + hasLens.set(true); + break; + } + } + } }); return hasLens.get(); }); + + + DiscoveryHandlers.addManaHolderDiscoverer(harness -> { + List holders = Lists.newArrayList(); + harness.getCtx().getCaster().getCapability(CuriosCapability.INVENTORY).ifPresent(handler -> { + for (var stacksHandler : handler.getCurios().values()) { + var stacks = stacksHandler.getStacks(); + for (int i = 0; i < stacks.getSlots(); i++) { + var stack = stacks.getStackInSlot(i); + if (ManaHelper.isManaItem(stack)) { + var holder = IXplatAbstractions.INSTANCE.findManaHolder(stack); + if (holder != null) { + holders.add(holder); + } + } + } + } + }); + + return holders; + }); + + + DiscoveryHandlers.addManaHolderDiscoverer(harness -> { + List holders = Lists.newArrayList(); + harness.getCtx().getCaster().getCapability(CuriosCapability.INVENTORY).ifPresent(handler -> { + for (var stacksHandler : handler.getCurios().values()) { + var stacks = stacksHandler.getStacks(); + for (int i = 0; i < stacks.getSlots(); i++) { + var stack = stacks.getStackInSlot(i); + if (ItemCreativeUnlocker.isDebug(stack)) { + holders.add(new DebugUnlockerHolder(stack)); + return; + } + } + } + }); + return holders; + }); } public static void onInterModEnqueue(final InterModEnqueueEvent event) { From 6c574fb9acc0d975fcedadbe7c7db7ac701db9ac Mon Sep 17 00:00:00 2001 From: "yrsegal@gmail.com" Date: Tue, 16 Aug 2022 23:07:02 -0400 Subject: [PATCH 2/8] swap choice of casting and other this makes trinkets preferentially recharge/erase/etc other things --- .../petrak/hexcasting/api/spell/casting/CastingContext.kt | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingContext.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingContext.kt index 909f187f..53540a8d 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingContext.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingContext.kt @@ -40,10 +40,10 @@ data class CastingContext( private val entitiesGivenMotion = mutableSetOf() inline fun getHeldItemToOperateOn(acceptItemIf: (ItemStack) -> Boolean): Pair { - val handItem = caster.getItemInHand(castingHand) + val handItem = caster.getItemInHand(otherHand) if (!acceptItemIf(handItem)) - return caster.getItemInHand(otherHand) to otherHand - return handItem to castingHand + return caster.getItemInHand(castingHand) to castingHand + return handItem to otherHand } /** From cc5267d2a4e4127a7816012d7063d71764f858f4 Mon Sep 17 00:00:00 2001 From: "yrsegal@gmail.com" Date: Tue, 16 Aug 2022 23:17:39 -0400 Subject: [PATCH 3/8] fix dupe bugs with yeeting --- .../main/java/at/petrak/hexcasting/api/spell/mishaps/Mishap.kt | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/Mishap.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/Mishap.kt index 41a3a588..6b5784f7 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/Mishap.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/Mishap.kt @@ -11,6 +11,7 @@ import at.petrak.hexcasting.api.utils.asTranslatedComponent import at.petrak.hexcasting.api.utils.lightPurple import at.petrak.hexcasting.common.lib.HexItems import at.petrak.hexcasting.ktxt.* +import at.petrak.hexcasting.xplat.IXplatAbstractions import net.minecraft.Util import net.minecraft.core.BlockPos import net.minecraft.network.chat.Component @@ -75,6 +76,8 @@ sealed class Mishap : Throwable() { protected fun yeetHeldItem(ctx: CastingContext, hand: InteractionHand) { val item = ctx.caster.getItemInHand(hand).copy() + if (hand == ctx.castingHand && IXplatAbstractions.INSTANCE.findHexHolder(item) != null) + return ctx.caster.setItemInHand(hand, ItemStack.EMPTY) val delta = ctx.caster.lookAngle.scale(0.5) From bde6f9ad5997c0b6e9f9ce937982927a7983c0c6 Mon Sep 17 00:00:00 2001 From: "yrsegal@gmail.com" Date: Wed, 17 Aug 2022 08:13:48 -0400 Subject: [PATCH 4/8] fix all the CC crashes --- Fabric/build.gradle | 1 - Fabric/gradle.properties | 2 +- Fabric/src/main/resources/fabric.mod.json | 2 +- 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/Fabric/build.gradle b/Fabric/build.gradle index 0f60e4e1..b71a22a2 100644 --- a/Fabric/build.gradle +++ b/Fabric/build.gradle @@ -69,7 +69,6 @@ dependencies { include "me.zeroeightsix:fiber:$fiberVersion" modImplementation "dev.onyxstudios.cardinal-components-api:cardinal-components-api:$cardinalComponentsVersion" - include "dev.onyxstudios.cardinal-components-api:cardinal-components-api:$cardinalComponentsVersion" modImplementation "com.jamieswhiteshirt:reach-entity-attributes:2.1.1" include "com.jamieswhiteshirt:reach-entity-attributes:2.1.1" diff --git a/Fabric/gradle.properties b/Fabric/gradle.properties index 0b6172c3..5e2c5833 100644 --- a/Fabric/gradle.properties +++ b/Fabric/gradle.properties @@ -3,7 +3,7 @@ fabricVersion=0.51.1+1.18.2 fabricLoaderVersion=0.14.5 fiberVersion=0.23.0-2 -cardinalComponentsVersion=4.1.4 +cardinalComponentsVersion=4.2.0 serializationHooksVersion=0.3.22 reiVersion=8.0.442 diff --git a/Fabric/src/main/resources/fabric.mod.json b/Fabric/src/main/resources/fabric.mod.json index 9c5f83d6..97183787 100644 --- a/Fabric/src/main/resources/fabric.mod.json +++ b/Fabric/src/main/resources/fabric.mod.json @@ -49,7 +49,7 @@ "minecraft": "=1.18.2", "java": ">=17", "fabric-language-kotlin": ">=1.7.4+kotlin.1.6.21", - "cardinal-components": "~4.1.4", + "cardinal-components": ">=4.2.0", "patchouli": ">=1.18.2-69", "paucal": "~0.4.6" }, From 36321c3cd0c3b61e0018ccae85c78952c8c1a2b8 Mon Sep 17 00:00:00 2001 From: "yrsegal@gmail.com" Date: Wed, 17 Aug 2022 13:38:29 -0400 Subject: [PATCH 5/8] discovery of grid scale modifiers and item slots --- .../api/misc/DiscoveryHandlers.java | 28 +++++++++++++++++++ .../api/spell/casting/CastingContext.kt | 14 ++++++++++ .../api/spell/casting/CastingHarness.kt | 4 +-- .../hexcasting/client/gui/GuiSpellcasting.kt | 8 ++---- .../hexcasting/common/items/ItemLens.java | 3 ++ .../items/magic/ItemCreativeUnlocker.java | 11 +++++--- 6 files changed, 57 insertions(+), 11 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/api/misc/DiscoveryHandlers.java b/Common/src/main/java/at/petrak/hexcasting/api/misc/DiscoveryHandlers.java index e9f04fb6..e9f3a98d 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/misc/DiscoveryHandlers.java +++ b/Common/src/main/java/at/petrak/hexcasting/api/misc/DiscoveryHandlers.java @@ -1,9 +1,12 @@ package at.petrak.hexcasting.api.misc; import at.petrak.hexcasting.api.addldata.ManaHolder; +import at.petrak.hexcasting.api.spell.casting.CastingContext; import at.petrak.hexcasting.api.spell.casting.CastingHarness; import com.google.common.collect.Lists; +import net.minecraft.util.ToFloatFunction; import net.minecraft.world.entity.player.Player; +import net.minecraft.world.item.ItemStack; import java.util.ArrayList; import java.util.List; @@ -13,6 +16,8 @@ import java.util.function.Predicate; public class DiscoveryHandlers { private static final List> HAS_LENS_PREDICATE = new ArrayList<>(); private static final List>> MANA_HOLDER_DISCOVERY = new ArrayList<>(); + private static final List> GRID_SCALE_MODIFIERS = new ArrayList<>(); + private static final List>> ITEM_SLOT_DISCOVERER = new ArrayList<>(); public static boolean hasLens(Player player) { for (var predicate : HAS_LENS_PREDICATE) { @@ -31,6 +36,21 @@ public class DiscoveryHandlers { return holders; } + public static float gridScaleModifier(Player player) { + float mod = 1; + for (var modifier : GRID_SCALE_MODIFIERS) { + mod *= modifier.apply(player); + } + return mod; + } + + public static List collectItemSlots(CastingContext ctx) { + List stacks = Lists.newArrayList(); + for (var discoverer : ITEM_SLOT_DISCOVERER) { + stacks.addAll(discoverer.apply(ctx)); + } + return stacks; + } public static void addLensPredicate(Predicate predicate) { HAS_LENS_PREDICATE.add(predicate); @@ -39,4 +59,12 @@ public class DiscoveryHandlers { public static void addManaHolderDiscoverer(Function> discoverer) { MANA_HOLDER_DISCOVERY.add(discoverer); } + + public static void addGridScaleModifier(ToFloatFunction modifier) { + GRID_SCALE_MODIFIERS.add(modifier); + } + + public static void addItemSlotDiscoverer(Function> discoverer) { + ITEM_SLOT_DISCOVERER.add(discoverer); + } } diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingContext.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingContext.kt index 53540a8d..dbf8c267 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingContext.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingContext.kt @@ -1,6 +1,7 @@ package at.petrak.hexcasting.api.spell.casting import at.petrak.hexcasting.api.HexAPI.modLoc +import at.petrak.hexcasting.api.misc.DiscoveryHandlers import at.petrak.hexcasting.api.mod.HexConfig import at.petrak.hexcasting.api.spell.Operator import at.petrak.hexcasting.api.spell.mishaps.MishapEntityTooFarAway @@ -133,6 +134,7 @@ data class CastingContext( // for what purpose i cannot imagine // http://redditpublic.com/images/b/b2/Items_slot_number.png looks right // and offhand is 150 Inventory.java:464 + // todo discovery? fun getOperativeSlot(stackOK: Predicate): Int? { val otherHandStack = this.caster.getItemInHand(this.otherHand) if (stackOK.test(otherHandStack)) { @@ -214,4 +216,16 @@ data class CastingContext( val advs = this.caster.advancements return advs.getOrStartProgress(adv!!).isDone } + + companion object { + init { + DiscoveryHandlers.addItemSlotDiscoverer { + val inv = it.caster.inventory + inv.items.toMutableList().apply { removeAt(inv.selected) }.asReversed().toMutableList().apply { + addAll(inv.offhand) + add(inv.getSelected()) + } + } + } + } } diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingHarness.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingHarness.kt index 1e88d402..100f5409 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingHarness.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingHarness.kt @@ -486,12 +486,12 @@ class CastingHarness private constructor( .mapNotNull(IXplatAbstractions.INSTANCE::findManaHolder) } DiscoveryHandlers.addManaHolderDiscoverer { - it.ctx.caster.armorSlots + it.ctx.caster.inventory.armor .filter(::isManaItem) .mapNotNull(IXplatAbstractions.INSTANCE::findManaHolder) } DiscoveryHandlers.addManaHolderDiscoverer { - listOf(it.ctx.caster.offhandItem) + it.ctx.caster.inventory.offhand .filter(::isManaItem) .mapNotNull(IXplatAbstractions.INSTANCE::findManaHolder) } diff --git a/Common/src/main/java/at/petrak/hexcasting/client/gui/GuiSpellcasting.kt b/Common/src/main/java/at/petrak/hexcasting/client/gui/GuiSpellcasting.kt index 4bb0a9f0..8d01bbb6 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/gui/GuiSpellcasting.kt +++ b/Common/src/main/java/at/petrak/hexcasting/client/gui/GuiSpellcasting.kt @@ -1,5 +1,6 @@ package at.petrak.hexcasting.client.gui +import at.petrak.hexcasting.api.misc.DiscoveryHandlers import at.petrak.hexcasting.api.mod.HexConfig import at.petrak.hexcasting.api.mod.HexItemTags import at.petrak.hexcasting.api.spell.casting.ControllerInfo @@ -10,13 +11,11 @@ import at.petrak.hexcasting.api.spell.math.HexCoord import at.petrak.hexcasting.api.spell.math.HexDir import at.petrak.hexcasting.api.spell.math.HexPattern import at.petrak.hexcasting.api.utils.asTranslatedComponent -import at.petrak.hexcasting.api.utils.otherHand import at.petrak.hexcasting.client.ShiftScrollListener import at.petrak.hexcasting.client.drawPatternFromPoints import at.petrak.hexcasting.client.drawSpot import at.petrak.hexcasting.client.ktxt.accumulatedScroll import at.petrak.hexcasting.client.sound.GridSoundInstance -import at.petrak.hexcasting.common.lib.HexItems import at.petrak.hexcasting.common.lib.HexSounds import at.petrak.hexcasting.common.network.MsgNewSpellPatternSyn import at.petrak.hexcasting.xplat.IClientXplatAbstractions @@ -352,13 +351,12 @@ class GuiSpellcasting( /** Distance between adjacent hex centers */ fun hexSize(): Float { - val hasLens = Minecraft.getInstance().player!! - .getItemInHand(otherHand(this.handOpenedWith)).`is`(HexItems.SCRYING_LENS) + val scaleModifier = DiscoveryHandlers.gridScaleModifier(Minecraft.getInstance().player) // Originally, we allowed 32 dots across. Assuming a 1920x1080 screen this allowed like 500-odd area. // Let's be generous and give them 512. val baseScale = sqrt(this.width.toDouble() * this.height / 512.0) - return baseScale.toFloat() * if (hasLens) 0.75f else 1f + return baseScale.toFloat() * scaleModifier } fun coordsOffset(): Vec2 = Vec2(this.width.toFloat() * 0.5f, this.height.toFloat() * 0.5f) diff --git a/Common/src/main/java/at/petrak/hexcasting/common/items/ItemLens.java b/Common/src/main/java/at/petrak/hexcasting/common/items/ItemLens.java index e370cb48..82864339 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/items/ItemLens.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/items/ItemLens.java @@ -38,6 +38,9 @@ public class ItemLens extends Item implements Wearable { DiscoveryHandlers.addLensPredicate(player -> player.getItemBySlot(EquipmentSlot.MAINHAND).is(HexItems.SCRYING_LENS)); DiscoveryHandlers.addLensPredicate(player -> player.getItemBySlot(EquipmentSlot.OFFHAND).is(HexItems.SCRYING_LENS)); DiscoveryHandlers.addLensPredicate(player -> player.getItemBySlot(EquipmentSlot.HEAD).is(HexItems.SCRYING_LENS)); + + DiscoveryHandlers.addGridScaleModifier(player -> player.getItemBySlot(EquipmentSlot.MAINHAND).is(HexItems.SCRYING_LENS) ? 0.75f : 1); + DiscoveryHandlers.addGridScaleModifier(player -> player.getItemBySlot(EquipmentSlot.OFFHAND).is(HexItems.SCRYING_LENS) ? 0.75f : 1); } public ItemLens(Properties pProperties) { diff --git a/Common/src/main/java/at/petrak/hexcasting/common/items/magic/ItemCreativeUnlocker.java b/Common/src/main/java/at/petrak/hexcasting/common/items/magic/ItemCreativeUnlocker.java index 8c92a21d..8865081c 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/items/magic/ItemCreativeUnlocker.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/items/magic/ItemCreativeUnlocker.java @@ -36,23 +36,26 @@ public class ItemCreativeUnlocker extends Item implements ManaHolderItem { if (!player.isCreative()) return List.of(); - for (ItemStack item : player.inventoryMenu.getItems()) { + for (ItemStack item : player.getInventory().items) { if (isDebug(item)) { return List.of(new DebugUnlockerHolder(item)); } } // Technically possible with commands! - for (ItemStack item : player.getArmorSlots()) { + for (ItemStack item : player.getInventory().armor) { if (isDebug(item)) { return List.of(new DebugUnlockerHolder(item)); } } - if (isDebug(player.getOffhandItem())) { - return List.of(new DebugUnlockerHolder(player.getOffhandItem())); + for (ItemStack item : player.getInventory().offhand) { + if (isDebug(item)) { + return List.of(new DebugUnlockerHolder(item)); + } } + return List.of(); }); } From 2a097603cb14564036770b137f1c8879beb9296e Mon Sep 17 00:00:00 2001 From: "yrsegal@gmail.com" Date: Wed, 17 Aug 2022 13:47:44 -0400 Subject: [PATCH 6/8] operative slots are now a discovery as well --- .../api/misc/DiscoveryHandlers.java | 13 ++++++ .../api/spell/casting/CastingContext.kt | 41 ++++++++----------- .../casting/operators/spells/OpPlaceBlock.kt | 5 +-- 3 files changed, 33 insertions(+), 26 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/api/misc/DiscoveryHandlers.java b/Common/src/main/java/at/petrak/hexcasting/api/misc/DiscoveryHandlers.java index e9f3a98d..05f0cdcd 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/misc/DiscoveryHandlers.java +++ b/Common/src/main/java/at/petrak/hexcasting/api/misc/DiscoveryHandlers.java @@ -18,6 +18,7 @@ public class DiscoveryHandlers { private static final List>> MANA_HOLDER_DISCOVERY = new ArrayList<>(); private static final List> GRID_SCALE_MODIFIERS = new ArrayList<>(); private static final List>> ITEM_SLOT_DISCOVERER = new ArrayList<>(); + private static final List>> OPERATIVE_SLOT_DISCOVERER = new ArrayList<>(); public static boolean hasLens(Player player) { for (var predicate : HAS_LENS_PREDICATE) { @@ -52,6 +53,14 @@ public class DiscoveryHandlers { return stacks; } + public static List collectOperableSlots(CastingContext ctx) { + List stacks = Lists.newArrayList(); + for (var discoverer : OPERATIVE_SLOT_DISCOVERER) { + stacks.addAll(discoverer.apply(ctx)); + } + return stacks; + } + public static void addLensPredicate(Predicate predicate) { HAS_LENS_PREDICATE.add(predicate); } @@ -67,4 +76,8 @@ public class DiscoveryHandlers { public static void addItemSlotDiscoverer(Function> discoverer) { ITEM_SLOT_DISCOVERER.add(discoverer); } + + public static void addOperativeSlotDiscoverer(Function> discoverer) { + OPERATIVE_SLOT_DISCOVERER.add(discoverer); + } } diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingContext.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingContext.kt index dbf8c267..0e0866bd 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingContext.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingContext.kt @@ -134,26 +134,12 @@ data class CastingContext( // for what purpose i cannot imagine // http://redditpublic.com/images/b/b2/Items_slot_number.png looks right // and offhand is 150 Inventory.java:464 - // todo discovery? - fun getOperativeSlot(stackOK: Predicate): Int? { - val otherHandStack = this.caster.getItemInHand(this.otherHand) - if (stackOK.test(otherHandStack)) { - return when (this.otherHand) { - InteractionHand.MAIN_HAND -> this.caster.inventory.selected - InteractionHand.OFF_HAND -> 150 - } - } - val anchorSlot = when (this.castingHand) { - // slot to the right of the wand - InteractionHand.MAIN_HAND -> (this.caster.inventory.selected + 1) % 9 - // first hotbar slot - InteractionHand.OFF_HAND -> 0 - } - for (delta in 0 until 9) { - val slot = (anchorSlot + delta) % 9 - val stack = this.caster.inventory.getItem(slot) + fun getOperativeSlot(stackOK: Predicate): ItemStack? { + val operable = DiscoveryHandlers.collectOperableSlots(this) + + for (stack in operable) { if (stackOK.test(stack)) { - return slot + return stack } } return null @@ -167,11 +153,8 @@ data class CastingContext( fun withdrawItem(item: Item, count: Int, actuallyRemove: Boolean): Boolean { if (this.caster.isCreative) return true - val inv = this.caster.inventory // TODO: withdraw from ender chest given a specific ender charm? - val stacksToExamine = inv.items.toMutableList().apply { removeAt(inv.selected) }.asReversed().toMutableList() - stacksToExamine.addAll(inv.offhand) - stacksToExamine.add(inv.getSelected()) + val stacksToExamine = DiscoveryHandlers.collectItemSlots(this) fun matches(stack: ItemStack): Boolean = !stack.isEmpty && stack.`is`(item) @@ -226,6 +209,18 @@ data class CastingContext( add(inv.getSelected()) } } + + DiscoveryHandlers.addOperativeSlotDiscoverer { + val slots = mutableListOf() + val anchorSlot = if (it.castingHand == InteractionHand.MAIN_HAND) (it.caster.inventory.selected + 1) % 9 else 0 + + slots.add(it.caster.getItemInHand(it.otherHand)) + for (delta in 0 until 9) { + val slot = (anchorSlot + delta) % 9 + slots.add(it.caster.inventory.getItem(slot)) + } + slots + } } } } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPlaceBlock.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPlaceBlock.kt index e67e3e68..bd3758b0 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPlaceBlock.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPlaceBlock.kt @@ -63,9 +63,8 @@ object OpPlaceBlock : SpellOperator { ) val bstate = ctx.world.getBlockState(pos) - val placeeSlot = ctx.getOperativeSlot { it.item is BlockItem } - if (placeeSlot != null) { - val placeeStack = ctx.caster.inventory.getItem(placeeSlot).copy() + val placeeStack = ctx.getOperativeSlot { it.item is BlockItem }?.copy() + if (placeeStack != null) { if (!IXplatAbstractions.INSTANCE.isPlacingAllowed(ctx.world, pos, placeeStack, ctx.caster)) return From 1afd21b5bbd10453e9031c40464df81c65d92d9d Mon Sep 17 00:00:00 2001 From: "yrsegal@gmail.com" Date: Thu, 18 Aug 2022 16:12:18 -0400 Subject: [PATCH 7/8] ManaHolders can now control recharging --- .../hexcasting/api/addldata/ManaHolder.java | 76 +++++++++++++++- .../hexcasting/api/item/ColorizerItem.java | 2 + .../hexcasting/api/item/DataHolderItem.java | 2 + .../hexcasting/api/item/HexHolderItem.java | 2 + .../hexcasting/api/item/ManaHolderItem.java | 24 +++++ .../api/spell/casting/CastingHarness.kt | 4 +- .../petrak/hexcasting/api/utils/ManaHelper.kt | 2 +- .../casting/operators/spells/OpRecharge.kt | 13 ++- .../items/magic/DebugUnlockerHolder.java | 22 +++-- .../items/magic/ItemCreativeUnlocker.java | 89 +++++++++++++------ .../assets/hexcasting/lang/en_us.json | 3 + .../hexcasting/fabric/cc/CCManaHolder.java | 5 ++ .../forge/cap/ForgeCapabilityHandler.java | 5 ++ 13 files changed, 198 insertions(+), 51 deletions(-) diff --git a/Common/src/main/java/at/petrak/hexcasting/api/addldata/ManaHolder.java b/Common/src/main/java/at/petrak/hexcasting/api/addldata/ManaHolder.java index 01debb5a..1c3fcd6b 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/addldata/ManaHolder.java +++ b/Common/src/main/java/at/petrak/hexcasting/api/addldata/ManaHolder.java @@ -1,25 +1,69 @@ package at.petrak.hexcasting.api.addldata; +import org.jetbrains.annotations.ApiStatus; + public interface ManaHolder { + /** + * Use {@code withdrawMana(-1, true)} + * + * @see ManaHolder#withdrawMana(int, boolean) + */ + @ApiStatus.OverrideOnly int getMana(); + /** + * Use {@code withdrawMana(-1, true) + insertMana(-1, true)} where possible + * + * @see ManaHolder#insertMana(int, boolean) + * @see ManaHolder#withdrawMana(int, boolean) + */ + @ApiStatus.OverrideOnly int getMaxMana(); + /** + * Use {@code insertMana(mana - withdrawMana(-1, true), false)} where possible + * + * @see ManaHolder#insertMana(int, boolean) + * @see ManaHolder#withdrawMana(int, boolean) + */ + @ApiStatus.OverrideOnly void setMana(int mana); + /** + * Whether this mana holder can have mana inserted into it. + */ boolean canRecharge(); + /** + * Whether this mana holder can be extracted from. + */ boolean canProvide(); + /** + * The priority for this mana holder to be selected when casting a hex. Higher priorities are taken first. + * + * By default, + * * Charged Amethyst has priority 1 + * * Amethyst Shards have priority 2 + * * Amethyst Dust has priority 3 + * * Items which hold mana have priority 40 + */ int getConsumptionPriority(); + /** + * Whether the mana inside this mana holder may be used to construct a battery. + */ boolean canConstructBattery(); + /** + * Withdraws mana from the holder. Returns the amount of mana extracted, which may be less or more than the cost. + * + * Even if {@link ManaHolder#canProvide} is false, you can still withdraw mana this way. + * + * Withdrawing a negative amount will act as though you attempted to withdraw as much mana as the holder contains. + */ default int withdrawMana(int cost, boolean simulate) { - if (!canProvide()) { - return 0; - } var manaHere = getMana(); if (cost < 0) { cost = manaHere; @@ -30,4 +74,30 @@ public interface ManaHolder { } return Math.min(cost, manaHere); } + + /** + * Inserts mana into the holder. Returns the amount of mana inserted, which may be less than the requested amount. + * + * Even if {@link ManaHolder#canRecharge} is false, you can still insert mana this way. + * + * Inserting a negative amount will act as though you attempted to insert exactly as much mana as the holder was missing. + */ + default int insertMana(int amount, boolean simulate) { + var manaHere = getMana(); + int emptySpace = getMaxMana() - manaHere; + if (emptySpace <= 0) { + return 0; + } + if (amount < 0) { + amount = emptySpace; + } + + int inserting = Math.min(amount, emptySpace); + + if (!simulate) { + var newMana = manaHere + inserting; + setMana(newMana); + } + return inserting; + } } diff --git a/Common/src/main/java/at/petrak/hexcasting/api/item/ColorizerItem.java b/Common/src/main/java/at/petrak/hexcasting/api/item/ColorizerItem.java index 8e9d5671..351e9d3a 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/item/ColorizerItem.java +++ b/Common/src/main/java/at/petrak/hexcasting/api/item/ColorizerItem.java @@ -2,9 +2,11 @@ package at.petrak.hexcasting.api.item; import net.minecraft.world.item.ItemStack; import net.minecraft.world.phys.Vec3; +import org.jetbrains.annotations.ApiStatus; import java.util.UUID; +@ApiStatus.OverrideOnly public interface ColorizerItem { int color(ItemStack stack, UUID owner, float time, Vec3 position); } diff --git a/Common/src/main/java/at/petrak/hexcasting/api/item/DataHolderItem.java b/Common/src/main/java/at/petrak/hexcasting/api/item/DataHolderItem.java index 6c11a534..f47b9f25 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/item/DataHolderItem.java +++ b/Common/src/main/java/at/petrak/hexcasting/api/item/DataHolderItem.java @@ -11,10 +11,12 @@ import net.minecraft.network.chat.TranslatableComponent; import net.minecraft.server.level.ServerLevel; import net.minecraft.world.item.ItemStack; import net.minecraft.world.item.TooltipFlag; +import org.jetbrains.annotations.ApiStatus; import org.jetbrains.annotations.Nullable; import java.util.List; +@ApiStatus.OverrideOnly public interface DataHolderItem { String TAG_OVERRIDE_VISUALLY = "VisualOverride"; diff --git a/Common/src/main/java/at/petrak/hexcasting/api/item/HexHolderItem.java b/Common/src/main/java/at/petrak/hexcasting/api/item/HexHolderItem.java index f2f875d8..82afab0b 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/item/HexHolderItem.java +++ b/Common/src/main/java/at/petrak/hexcasting/api/item/HexHolderItem.java @@ -3,10 +3,12 @@ package at.petrak.hexcasting.api.item; import at.petrak.hexcasting.api.spell.SpellDatum; import net.minecraft.server.level.ServerLevel; import net.minecraft.world.item.ItemStack; +import org.jetbrains.annotations.ApiStatus; import org.jetbrains.annotations.Nullable; import java.util.List; +@ApiStatus.OverrideOnly public interface HexHolderItem extends ManaHolderItem { boolean canDrawManaFromInventory(ItemStack stack); diff --git a/Common/src/main/java/at/petrak/hexcasting/api/item/ManaHolderItem.java b/Common/src/main/java/at/petrak/hexcasting/api/item/ManaHolderItem.java index 4247bba9..ac7c0d9e 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/item/ManaHolderItem.java +++ b/Common/src/main/java/at/petrak/hexcasting/api/item/ManaHolderItem.java @@ -1,7 +1,12 @@ package at.petrak.hexcasting.api.item; import net.minecraft.world.item.ItemStack; +import org.jetbrains.annotations.ApiStatus; +/** + * This interface should not be accessed direc + */ +@ApiStatus.OverrideOnly public interface ManaHolderItem { int getMana(ItemStack stack); @@ -32,4 +37,23 @@ public interface ManaHolderItem { } return Math.min(cost, manaHere); } + + default int insertMana(ItemStack stack, int amount, boolean simulate) { + var manaHere = getMana(stack); + int emptySpace = getMaxMana(stack) - manaHere; + if (emptySpace <= 0) { + return 0; + } + if (amount < 0) { + amount = emptySpace; + } + + int inserting = Math.min(amount, emptySpace); + + if (!simulate) { + var newMana = manaHere + inserting; + setMana(stack, newMana); + } + return inserting; + } } diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingHarness.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingHarness.kt index 100f5409..9a2cd337 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingHarness.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingHarness.kt @@ -395,9 +395,9 @@ class CastingHarness private constructor( val casterHexHolder = IXplatAbstractions.INSTANCE.findHexHolder(casterStack) val hexHolderDrawsFromInventory = if (casterHexHolder != null) { if (casterManaHolder != null) { - val manaAvailable = casterManaHolder.mana + val manaAvailable = casterManaHolder.withdrawMana(-1, true) val manaToTake = min(costLeft, manaAvailable) - if (!fake) casterManaHolder.mana = manaAvailable - manaToTake + if (!fake) casterManaHolder.withdrawMana(manaToTake, false) costLeft -= manaToTake } casterHexHolder.canDrawManaFromInventory() diff --git a/Common/src/main/java/at/petrak/hexcasting/api/utils/ManaHelper.kt b/Common/src/main/java/at/petrak/hexcasting/api/utils/ManaHelper.kt index fe020dfd..4d89dbf7 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/utils/ManaHelper.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/utils/ManaHelper.kt @@ -62,7 +62,7 @@ fun compareManaItem(aMana: ManaHolder, bMana: ManaHolder): Int { if (priority != 0) return priority - return aMana.mana - bMana.mana + return aMana.withdrawMana(-1, true) - bMana.withdrawMana(-1, true) } fun manaBarColor(mana: Int, maxMana: Int): Int { diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpRecharge.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpRecharge.kt index c9dc25ce..fba454b0 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpRecharge.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpRecharge.kt @@ -18,7 +18,7 @@ object OpRecharge : SpellOperator { ): Triple>? { val (handStack, hand) = ctx.getHeldItemToOperateOn { val mana = IXplatAbstractions.INSTANCE.findManaHolder(it) - mana != null && mana.canRecharge() && mana.mana /* doo doo da do doo */ < mana.maxMana + mana != null && mana.canRecharge() && mana.insertMana(-1, true) != 0 } val mana = IXplatAbstractions.INSTANCE.findManaHolder(handStack) @@ -40,7 +40,7 @@ object OpRecharge : SpellOperator { ) } - if (mana.mana >= mana.maxMana) + if (mana.insertMana(-1, true) == 0) return null return Triple( @@ -54,19 +54,18 @@ object OpRecharge : SpellOperator { override fun cast(ctx: CastingContext) { val (handStack) = ctx.getHeldItemToOperateOn { val mana = IXplatAbstractions.INSTANCE.findManaHolder(it) - mana != null && mana.canRecharge() && mana.mana < mana.maxMana + mana != null && mana.canRecharge() && mana.insertMana(-1, true) != 0 } val mana = IXplatAbstractions.INSTANCE.findManaHolder(handStack) if (mana != null && itemEntity.isAlive) { val entityStack = itemEntity.item.copy() - val maxMana = mana.maxMana - val existingMana = mana.mana + val emptySpace = mana.insertMana(-1, true) - val manaAmt = extractMana(entityStack, maxMana - existingMana) + val manaAmt = extractMana(entityStack, emptySpace) - mana.mana = manaAmt + existingMana + mana.insertMana(manaAmt, false) itemEntity.item = entityStack if (entityStack.isEmpty) diff --git a/Common/src/main/java/at/petrak/hexcasting/common/items/magic/DebugUnlockerHolder.java b/Common/src/main/java/at/petrak/hexcasting/common/items/magic/DebugUnlockerHolder.java index b6e65fe3..614237b6 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/items/magic/DebugUnlockerHolder.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/items/magic/DebugUnlockerHolder.java @@ -1,11 +1,8 @@ package at.petrak.hexcasting.common.items.magic; import at.petrak.hexcasting.api.addldata.ManaHolder; -import at.petrak.hexcasting.api.utils.NBTHelper; import net.minecraft.world.item.ItemStack; -import java.util.Arrays; - public record DebugUnlockerHolder(ItemStack creativeUnlocker) implements ManaHolder { @Override public int getMana() { @@ -24,7 +21,7 @@ public record DebugUnlockerHolder(ItemStack creativeUnlocker) implements ManaHol @Override public boolean canRecharge() { - return false; + return true; } @Override @@ -44,14 +41,15 @@ public record DebugUnlockerHolder(ItemStack creativeUnlocker) implements ManaHol @Override public int withdrawMana(int cost, boolean simulate) { - int[] arr = NBTHelper.getIntArray(creativeUnlocker, ItemCreativeUnlocker.TAG_EXTRACTIONS); - if (arr == null) { - arr = new int[0]; - } - int[] newArr = Arrays.copyOf(arr, arr.length + 1); - newArr[newArr.length - 1] = cost; - NBTHelper.putIntArray(creativeUnlocker, ItemCreativeUnlocker.TAG_EXTRACTIONS, newArr); + ItemCreativeUnlocker.addToIntArray(creativeUnlocker, ItemCreativeUnlocker.TAG_EXTRACTIONS, cost); - return cost < 0 ? 1 : cost; + return cost < 0 ? getMana() : cost; + } + + @Override + public int insertMana(int amount, boolean simulate) { + ItemCreativeUnlocker.addToIntArray(creativeUnlocker, ItemCreativeUnlocker.TAG_INSERTIONS, amount); + + return amount; } } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/items/magic/ItemCreativeUnlocker.java b/Common/src/main/java/at/petrak/hexcasting/common/items/magic/ItemCreativeUnlocker.java index 8865081c..088e14f4 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/items/magic/ItemCreativeUnlocker.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/items/magic/ItemCreativeUnlocker.java @@ -1,10 +1,12 @@ package at.petrak.hexcasting.common.items.magic; +import at.petrak.hexcasting.api.block.circle.BlockEntityAbstractImpetus; import at.petrak.hexcasting.api.item.ManaHolderItem; import at.petrak.hexcasting.api.misc.DiscoveryHandlers; import at.petrak.hexcasting.api.misc.ManaConstants; import at.petrak.hexcasting.api.utils.NBTHelper; import at.petrak.hexcasting.common.lib.HexItems; +import at.petrak.hexcasting.common.lib.HexSounds; import net.minecraft.ChatFormatting; import net.minecraft.Util; import net.minecraft.advancements.Advancement; @@ -12,13 +14,17 @@ import net.minecraft.locale.Language; import net.minecraft.network.chat.*; import net.minecraft.server.level.ServerLevel; import net.minecraft.server.level.ServerPlayer; +import net.minecraft.sounds.SoundSource; import net.minecraft.util.Mth; +import net.minecraft.world.InteractionResult; import net.minecraft.world.entity.Entity; import net.minecraft.world.entity.LivingEntity; import net.minecraft.world.item.Item; import net.minecraft.world.item.ItemStack; import net.minecraft.world.item.TooltipFlag; +import net.minecraft.world.item.context.UseOnContext; import net.minecraft.world.level.Level; +import net.minecraft.world.level.block.entity.BlockEntity; import org.jetbrains.annotations.Nullable; import java.util.ArrayList; @@ -79,6 +85,7 @@ public class ItemCreativeUnlocker extends Item implements ManaHolderItem { } public static final String TAG_EXTRACTIONS = "extractions"; + public static final String TAG_INSERTIONS = "insertions"; public ItemCreativeUnlocker(Properties properties) { super(properties); @@ -106,23 +113,37 @@ public class ItemCreativeUnlocker extends Item implements ManaHolderItem { @Override public boolean canRecharge(ItemStack stack) { - return false; + return true; + } + + public static void addToIntArray(ItemStack stack, String tag, int n) { + int[] arr = NBTHelper.getIntArray(stack, tag); + if (arr == null) { + arr = new int[0]; + } + int[] newArr = Arrays.copyOf(arr, arr.length + 1); + newArr[newArr.length - 1] = n; + NBTHelper.putIntArray(stack, tag, newArr); } @Override public int withdrawMana(ItemStack stack, int cost, boolean simulate) { // In case it's withdrawn through other means if (!simulate && isDebug(stack)) { - int[] arr = NBTHelper.getIntArray(stack, TAG_EXTRACTIONS); - if (arr == null) { - arr = new int[0]; - } - int[] newArr = Arrays.copyOf(arr, arr.length + 1); - newArr[newArr.length - 1] = cost; - NBTHelper.putIntArray(stack, TAG_EXTRACTIONS, newArr); + addToIntArray(stack, TAG_EXTRACTIONS, cost); } - return cost < 0 ? 1 : cost; + return cost < 0 ? getMana(stack) : cost; + } + + @Override + public int insertMana(ItemStack stack, int amount, boolean simulate) { + // In case it's inserted through other means + if (!simulate && isDebug(stack)) { + addToIntArray(stack, TAG_INSERTIONS, amount); + } + + return amount < 0 ? getMaxMana(stack) : amount; } @Override @@ -133,28 +154,44 @@ public class ItemCreativeUnlocker extends Item implements ManaHolderItem { @Override public void inventoryTick(ItemStack stack, Level level, Entity entity, int slot, boolean selected) { if (isDebug(stack) && !level.isClientSide) { - int[] arr = NBTHelper.getIntArray(stack, TAG_EXTRACTIONS); - if (arr != null) { - NBTHelper.remove(stack, TAG_EXTRACTIONS); - for (int i : arr) { - if (i < 0) { - entity.sendMessage(new TranslatableComponent("hexcasting.debug.mana_withdrawn", - stack.getDisplayName(), - new TranslatableComponent("hexcasting.debug.all_mana").withStyle(ChatFormatting.GRAY)) - .withStyle(ChatFormatting.LIGHT_PURPLE), Util.NIL_UUID); - } else { - entity.sendMessage(new TranslatableComponent("hexcasting.debug.mana_withdrawn.with_dust", - stack.getDisplayName(), - new TextComponent("" + i).withStyle(ChatFormatting.WHITE), - new TextComponent(String.format("%.2f", i * 1.0 / ManaConstants.DUST_UNIT)).withStyle( - ChatFormatting.WHITE)) - .withStyle(ChatFormatting.LIGHT_PURPLE), Util.NIL_UUID); - } + debugDisplay(stack, TAG_EXTRACTIONS, "withdrawn", "all_mana", entity); + debugDisplay(stack, TAG_INSERTIONS, "inserted", "infinite_mana", entity); + } + } + + private void debugDisplay(ItemStack stack, String tag, String langKey, String allKey, Entity entity) { + int[] arr = NBTHelper.getIntArray(stack, tag); + if (arr != null) { + NBTHelper.remove(stack, tag); + for (int i : arr) { + if (i < 0) { + entity.sendMessage(new TranslatableComponent("hexcasting.debug.mana_" + langKey, + stack.getDisplayName(), + new TranslatableComponent("hexcasting.debug." + allKey).withStyle(ChatFormatting.GRAY)) + .withStyle(ChatFormatting.LIGHT_PURPLE), Util.NIL_UUID); + } else { + entity.sendMessage(new TranslatableComponent("hexcasting.debug.mana_" + langKey + ".with_dust", + stack.getDisplayName(), + new TextComponent("" + i).withStyle(ChatFormatting.WHITE), + new TextComponent(String.format("%.2f", i * 1.0 / ManaConstants.DUST_UNIT)).withStyle( + ChatFormatting.WHITE)) + .withStyle(ChatFormatting.LIGHT_PURPLE), Util.NIL_UUID); } } } } + @Override + public InteractionResult useOn(UseOnContext context) { + BlockEntity be = context.getLevel().getBlockEntity(context.getClickedPos()); + if (be instanceof BlockEntityAbstractImpetus impetus) { + impetus.setInfiniteMana(); + context.getLevel().playSound(null, context.getClickedPos(), HexSounds.SPELL_CIRCLE_FIND_BLOCK, SoundSource.PLAYERS, 1f, 1f); + return InteractionResult.sidedSuccess(context.getLevel().isClientSide()); + } + return InteractionResult.PASS; + } + @Override public ItemStack finishUsingItem(ItemStack stack, Level level, LivingEntity consumer) { if (level instanceof ServerLevel slevel && consumer instanceof ServerPlayer player) { diff --git a/Common/src/main/resources/assets/hexcasting/lang/en_us.json b/Common/src/main/resources/assets/hexcasting/lang/en_us.json index 3a378534..71b877f2 100644 --- a/Common/src/main/resources/assets/hexcasting/lang/en_us.json +++ b/Common/src/main/resources/assets/hexcasting/lang/en_us.json @@ -182,7 +182,10 @@ "hexcasting.pattern.unknown": "Unknown pattern resource location %s", "hexcasting.debug.mana_withdrawn": "%s - Mana withdrawn: %s", "hexcasting.debug.mana_withdrawn.with_dust": "%s - Mana withdrawn: %s (%s in dust)", + "hexcasting.debug.mana_inserted": "%s - Mana inserted: %s", + "hexcasting.debug.mana_inserted.with_dust": "%s - Mana inserted: %s (%s in dust)", "hexcasting.debug.all_mana": "Entire contents", + "hexcasting.debug.infinite_mana": "Infinite", "hexcasting.message.cant_overcast": "That Hex needed more media than I had... I should double-check my math.", "hexcasting.message.cant_great_spell": "The spell failed, somehow... am I not skilled enough?", diff --git a/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCManaHolder.java b/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCManaHolder.java index c1096a9b..95cba35d 100644 --- a/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCManaHolder.java +++ b/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCManaHolder.java @@ -62,6 +62,11 @@ public abstract class CCManaHolder extends ItemComponent implements ManaHolder { public int withdrawMana(int cost, boolean simulate) { return this.manaHolder.withdrawMana(this.stack, cost, simulate); } + + @Override + public int insertMana(int amount, boolean simulate) { + return this.manaHolder.insertMana(this.stack, amount, simulate); + } } public static class Static extends CCManaHolder { diff --git a/Forge/src/main/java/at/petrak/hexcasting/forge/cap/ForgeCapabilityHandler.java b/Forge/src/main/java/at/petrak/hexcasting/forge/cap/ForgeCapabilityHandler.java index e6227acd..c8c930a7 100644 --- a/Forge/src/main/java/at/petrak/hexcasting/forge/cap/ForgeCapabilityHandler.java +++ b/Forge/src/main/java/at/petrak/hexcasting/forge/cap/ForgeCapabilityHandler.java @@ -211,6 +211,11 @@ public class ForgeCapabilityHandler { public int withdrawMana(int cost, boolean simulate) { return holder.withdrawMana(stack, cost, simulate); } + + @Override + public int insertMana(int amount, boolean simulate) { + return holder.insertMana(stack, amount, simulate); + } } private record StaticDatumHolder(Function> provider, From 63be2d9a96bb13b490e4c78713ae4d6ac0fe5c15 Mon Sep 17 00:00:00 2001 From: "yrsegal@gmail.com" Date: Thu, 18 Aug 2022 17:06:06 -0400 Subject: [PATCH 8/8] fix annotations not compiling --- Common/build.gradle | 3 +++ Fabric/build.gradle | 2 ++ Forge/build.gradle | 3 +++ gradle.properties | 4 +++- 4 files changed, 11 insertions(+), 1 deletion(-) diff --git a/Common/build.gradle b/Common/build.gradle index c8bba05d..b703a769 100644 --- a/Common/build.gradle +++ b/Common/build.gradle @@ -38,6 +38,9 @@ dependencies { compileOnly "at.petra-k.paucal:paucal-common-$minecraftVersion:$paucalVersion" compileOnly "vazkii.patchouli:Patchouli-xplat:$minecraftVersion-$patchouliVersion" + compileOnly "org.jetbrains:annotations:$jetbrainsAnnotationsVersion" + testCompileOnly "org.jetbrains:annotations:$jetbrainsAnnotationsVersion" + testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.1' testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.1' } diff --git a/Fabric/build.gradle b/Fabric/build.gradle index b71a22a2..53a55f76 100644 --- a/Fabric/build.gradle +++ b/Fabric/build.gradle @@ -57,6 +57,8 @@ dependencies { modImplementation "net.fabricmc.fabric-api:fabric-api:${fabricVersion}" // Reqs + compileOnly "org.jetbrains:annotations:$jetbrainsAnnotationsVersion" + testCompileOnly "org.jetbrains:annotations:$jetbrainsAnnotationsVersion" compileOnly "com.demonwav.mcdev:annotations:1.0" implementation group: 'com.google.code.findbugs', name: 'jsr305', version: '3.0.1' diff --git a/Forge/build.gradle b/Forge/build.gradle index 3150cb41..103f93bd 100644 --- a/Forge/build.gradle +++ b/Forge/build.gradle @@ -132,6 +132,9 @@ dependencies { minecraft "net.minecraftforge:forge:${minecraftVersion}-${forgeVersion}" compileOnly project(":Common") + compileOnly "org.jetbrains:annotations:$jetbrainsAnnotationsVersion" + testCompileOnly "org.jetbrains:annotations:$jetbrainsAnnotationsVersion" + annotationProcessor 'org.spongepowered:mixin:0.8.5:processor' compileOnly fg.deobf("at.petra-k.paucal:paucal-forge-$minecraftVersion:$paucalVersion") diff --git a/gradle.properties b/gradle.properties index f4f31874..11397170 100644 --- a/gradle.properties +++ b/gradle.properties @@ -6,6 +6,8 @@ org.gradle.daemon=false modID=hexcasting modName=Hex Casting +jetbrainsAnnotationsVersion=23.0.0 + minecraftVersion=1.18.2 kotlinVersion=1.6.21 modVersion=0.9.2 @@ -14,4 +16,4 @@ paucalVersion=0.4.6 patchouliVersion=69 jeiVersion=9.5.3.143 -pehkuiVersion=3.3.2 \ No newline at end of file +pehkuiVersion=3.3.2