diff --git a/Common/src/main/java/at/petrak/hexcasting/api/PatternRegistry.kt b/Common/src/main/java/at/petrak/hexcasting/api/PatternRegistry.kt index 48eef77a..079c4593 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/PatternRegistry.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/PatternRegistry.kt @@ -129,7 +129,7 @@ object PatternRegistry { } for ((sig, entry) in this.regularPatternLookup) { if (entry.opId == opId) { - val pattern = HexPattern.FromAnglesSig(sig, entry.preferredStart) + val pattern = HexPattern.fromAngles(sig, entry.preferredStart) return PatternEntry(pattern, this.operatorLookup[entry.opId]!!, false) } } diff --git a/Common/src/main/java/at/petrak/hexcasting/api/addldata/DataHolder.java b/Common/src/main/java/at/petrak/hexcasting/api/addldata/DataHolder.java index 87b5e770..b16923df 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/addldata/DataHolder.java +++ b/Common/src/main/java/at/petrak/hexcasting/api/addldata/DataHolder.java @@ -13,7 +13,7 @@ public interface DataHolder { default SpellDatum readDatum(ServerLevel world) { var tag = readRawDatum(); if (tag != null) { - return SpellDatum.DeserializeFromNBT(tag, world); + return SpellDatum.fromNBT(tag, world); } else { return null; } diff --git a/Common/src/main/java/at/petrak/hexcasting/api/block/circle/BlockEntityAbstractImpetus.java b/Common/src/main/java/at/petrak/hexcasting/api/block/circle/BlockEntityAbstractImpetus.java index a0dac65a..0f0df6ef 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/block/circle/BlockEntityAbstractImpetus.java +++ b/Common/src/main/java/at/petrak/hexcasting/api/block/circle/BlockEntityAbstractImpetus.java @@ -132,7 +132,7 @@ public abstract class BlockEntityAbstractImpetus extends HexBlockEntity implemen if (this.activator != null && this.colorizer != null && this.nextBlock != null && this.trackedBlocks != null) { tag.putUUID(TAG_ACTIVATOR, this.activator); tag.put(TAG_NEXT_BLOCK, NbtUtils.writeBlockPos(this.nextBlock)); - tag.put(TAG_COLORIZER, this.colorizer.serialize()); + tag.put(TAG_COLORIZER, this.colorizer.serializeToNBT()); tag.putBoolean(TAG_FOUND_ALL, this.foundAll); var trackeds = new ListTag(); @@ -155,7 +155,7 @@ public abstract class BlockEntityAbstractImpetus extends HexBlockEntity implemen tag.contains(TAG_NEXT_BLOCK, Tag.TAG_COMPOUND) && tag.contains(TAG_TRACKED_BLOCKS, Tag.TAG_LIST)) { this.activator = tag.getUUID(TAG_ACTIVATOR); - this.colorizer = FrozenColorizer.deserialize(tag.getCompound(TAG_COLORIZER)); + this.colorizer = FrozenColorizer.fromNBT(tag.getCompound(TAG_COLORIZER)); this.nextBlock = NbtUtils.readBlockPos(tag.getCompound(TAG_NEXT_BLOCK)); this.foundAll = tag.getBoolean(TAG_FOUND_ALL); var trackeds = tag.getList(TAG_TRACKED_BLOCKS, Tag.TAG_COMPOUND); 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 33b4f214..ea010ce3 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 @@ -28,7 +28,7 @@ public interface DataHolderItem { var tag = dh.readDatumTag(stack); if (tag != null) { - return SpellDatum.DeserializeFromNBT(tag, world); + return SpellDatum.fromNBT(tag, world); } else { return null; } @@ -47,7 +47,7 @@ public interface DataHolderItem { TooltipFlag pIsAdvanced) { var datumTag = self.readDatumTag(pStack); if (datumTag != null) { - var component = SpellDatum.DisplayFromTag(datumTag); + var component = SpellDatum.displayFromNBT(datumTag); pTooltipComponents.add(new TranslatableComponent("hexcasting.spelldata.onitem", component)); if (pIsAdvanced.isAdvanced()) { diff --git a/Common/src/main/java/at/petrak/hexcasting/api/misc/FrozenColorizer.java b/Common/src/main/java/at/petrak/hexcasting/api/misc/FrozenColorizer.java index 4dd2077a..265644d6 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/misc/FrozenColorizer.java +++ b/Common/src/main/java/at/petrak/hexcasting/api/misc/FrozenColorizer.java @@ -29,14 +29,14 @@ public record FrozenColorizer(ItemStack item, UUID owner) { public static final Supplier DEFAULT = () -> new FrozenColorizer(new ItemStack(HexItems.DYE_COLORIZERS.get(DyeColor.WHITE)), Util.NIL_UUID); - public CompoundTag serialize() { + public CompoundTag serializeToNBT() { var out = new CompoundTag(); - out.put(TAG_STACK, HexUtils.serialize(this.item)); + out.put(TAG_STACK, HexUtils.serializeToNBT(this.item)); out.putUUID(TAG_OWNER, this.owner); return out; } - public static FrozenColorizer deserialize(CompoundTag tag) { + public static FrozenColorizer fromNBT(CompoundTag tag) { if (tag.isEmpty()) { return FrozenColorizer.DEFAULT.get(); } diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/OperatorUtils.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/OperatorUtils.kt index f4f83194..172c2bc0 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/OperatorUtils.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/OperatorUtils.kt @@ -12,7 +12,7 @@ import net.minecraft.world.entity.Entity import net.minecraft.world.phys.Vec3 import kotlin.math.abs -fun GetNumOrVec(datum: SpellDatum<*>, reverseIdx: Int): Either = +fun numOrVec(datum: SpellDatum<*>, reverseIdx: Int): Either = when (datum.payload) { is Double -> Either.left(datum.payload) is Vec3 -> Either.right(datum.payload) @@ -23,7 +23,7 @@ fun GetNumOrVec(datum: SpellDatum<*>, reverseIdx: Int): Either = ) } -fun GetNumOrList(datum: SpellDatum<*>, reverseIdx: Int): Either = +fun numOrList(datum: SpellDatum<*>, reverseIdx: Int): Either = when (datum.payload) { is Double -> Either.left(datum.payload) is SpellList -> Either.right(datum.payload) diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/ParticleSpray.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/ParticleSpray.kt index 798f456b..617ee5c0 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/ParticleSpray.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/ParticleSpray.kt @@ -9,12 +9,12 @@ import net.minecraft.world.phys.Vec3 data class ParticleSpray(val pos: Vec3, val vel: Vec3, val fuzziness: Double, val spread: Double, val count: Int = 20) { companion object { @JvmStatic - fun Burst(pos: Vec3, size: Double, count: Int = 20): ParticleSpray { + fun burst(pos: Vec3, size: Double, count: Int = 20): ParticleSpray { return ParticleSpray(pos, Vec3(size, 0.0, 0.0), 0.0, 3.14, count) } @JvmStatic - fun Cloud(pos: Vec3, size: Double, count: Int = 20): ParticleSpray { + fun cloud(pos: Vec3, size: Double, count: Int = 20): ParticleSpray { return ParticleSpray(pos, Vec3(0.0, 0.001, 0.0), size, 0.0, count) } } diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/SpellDatum.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/SpellDatum.kt index 91378ebc..45e1438a 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/SpellDatum.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/SpellDatum.kt @@ -3,11 +3,12 @@ package at.petrak.hexcasting.api.spell import at.petrak.hexcasting.api.spell.casting.CastingContext import at.petrak.hexcasting.api.spell.math.HexPattern import at.petrak.hexcasting.api.spell.mishaps.MishapInvalidSpellDatumType -import at.petrak.hexcasting.api.utils.HexUtils -import at.petrak.hexcasting.api.utils.HexUtils.serializeToNBT -import at.petrak.hexcasting.api.utils.getList +import at.petrak.hexcasting.api.utils.* import net.minecraft.ChatFormatting -import net.minecraft.nbt.* +import net.minecraft.nbt.CompoundTag +import net.minecraft.nbt.DoubleTag +import net.minecraft.nbt.NbtUtils +import net.minecraft.nbt.Tag import net.minecraft.network.chat.Component import net.minecraft.network.chat.TextComponent import net.minecraft.network.chat.TranslatableComponent @@ -22,7 +23,7 @@ import java.util.* * We use the following types: * * [Entity] * * [Double] - * * [Vec3][net.minecraft.world.phys.Vec3] as both position and (when normalized) direction + * * [Vec3] as both position and (when normalized) direction * * [Widget]; [Widget.NULL] is used as our null value * * [SpellList] * * [HexPattern]! Yes, we have meta-evaluation everyone. @@ -51,10 +52,7 @@ class SpellDatum private constructor(val payload: T) { TAG_VEC3, pl.serializeToNBT() ) is SpellList -> { - val subtag = ListTag() - for (elt in pl) - subtag.add(elt.serializeToNBT()) - out.put(TAG_LIST, subtag) + out.put(TAG_LIST, pl.serializeToNBT()) } is Widget -> { out.putString(TAG_WIDGET, pl.name) @@ -85,7 +83,7 @@ class SpellDatum private constructor(val payload: T) { fun display(): Component { val nbt = this.serializeToNBT() - return DisplayFromTag(nbt) + return displayFromNBT(nbt) } fun getType(): DatumType = @@ -101,6 +99,7 @@ class SpellDatum private constructor(val payload: T) { companion object { @JvmStatic + @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN") fun make(payload: Any): SpellDatum<*> = if (payload is SpellDatum<*>) { payload @@ -114,23 +113,23 @@ class SpellDatum private constructor(val payload: T) { } else if (payload is Vec3) { SpellDatum( Vec3( - HexUtils.FixNANs(payload.x), - HexUtils.FixNANs(payload.y), - HexUtils.FixNANs(payload.z), + fixNAN(payload.x), + fixNAN(payload.y), + fixNAN(payload.z), ) ) - } else if (IsValidType(payload)) { + } else if (isValidType(payload)) { SpellDatum(payload) } else if (payload is java.lang.Double) { // Check to see if it's a java *boxed* double, for when we call this from Java val num = payload.toDouble() - SpellDatum(HexUtils.FixNANs(num)) + SpellDatum(fixNAN(num)) } else { throw MishapInvalidSpellDatumType(payload) } @JvmStatic - fun DeserializeFromNBT(nbt: CompoundTag, world: ServerLevel): SpellDatum<*> { + fun fromNBT(nbt: CompoundTag, world: ServerLevel): SpellDatum<*> { val keys = nbt.allKeys if (keys.size != 1) throw IllegalArgumentException("Expected exactly one kv pair: $nbt") @@ -144,21 +143,15 @@ class SpellDatum private constructor(val payload: T) { SpellDatum(if (entity == null || !entity.isAlive) Widget.NULL else entity) } TAG_DOUBLE -> SpellDatum(nbt.getDouble(key)) - TAG_VEC3 -> SpellDatum(HexUtils.DeserializeVec3FromNBT(nbt.getLongArray(key))) + TAG_VEC3 -> SpellDatum(vecFromNBT(nbt.getLongArray(key))) TAG_LIST -> { - val arr = nbt.getList(key, Tag.TAG_COMPOUND) - val out = ArrayList>(arr.size) - for (subtag in arr) { - // this is safe because otherwise we wouldn't have been able to get the list before - out.add(DeserializeFromNBT(subtag as CompoundTag, world)) - } - SpellDatum(SpellList.LList(0, out)) + SpellDatum(SpellList.fromNBT(nbt.getList(key, Tag.TAG_COMPOUND), world)) } TAG_WIDGET -> { SpellDatum(Widget.valueOf(nbt.getString(key))) } TAG_PATTERN -> { - SpellDatum(HexPattern.DeserializeFromNBT(nbt.getCompound(TAG_PATTERN))) + SpellDatum(HexPattern.fromNBT(nbt.getCompound(TAG_PATTERN))) } else -> throw IllegalArgumentException("Unknown key $key: $nbt") } @@ -171,11 +164,11 @@ class SpellDatum private constructor(val payload: T) { ) ) @JvmStatic - fun DeserializeFromNBT(nbt: CompoundTag, ctx: CastingContext): SpellDatum<*> = - DeserializeFromNBT(nbt, ctx.world) + fun fromNBT(nbt: CompoundTag, ctx: CastingContext): SpellDatum<*> = + fromNBT(nbt, ctx.world) @JvmStatic - fun DisplayFromTag(nbt: CompoundTag): Component { + fun displayFromNBT(nbt: CompoundTag): Component { val keys = nbt.allKeys if (keys.size != 1) throw IllegalArgumentException("Expected exactly one kv pair: $nbt") @@ -188,7 +181,7 @@ class SpellDatum private constructor(val payload: T) { ) ).withStyle(ChatFormatting.GREEN) TAG_VEC3 -> { - val vec = HexUtils.DeserializeVec3FromNBT(nbt.getLongArray(key)) + val vec = vecFromNBT(nbt.getLongArray(key)) // the focus color is really more red, but we don't want to show an error-y color TextComponent( String.format( @@ -205,7 +198,7 @@ class SpellDatum private constructor(val payload: T) { val arr = nbt.getList(key, Tag.TAG_COMPOUND) for ((i, subtag) in arr.withIndex()) { // this is safe because otherwise we wouldn't have been able to get the list before - out.append(DisplayFromTag(subtag as CompoundTag)) + out.append(displayFromNBT(subtag as CompoundTag)) if (i != arr.lastIndex) { out.append(", ") } @@ -223,7 +216,7 @@ class SpellDatum private constructor(val payload: T) { else TextComponent(widget.toString()).withStyle(ChatFormatting.DARK_PURPLE) } TAG_PATTERN -> { - val pat = HexPattern.DeserializeFromNBT(nbt.getCompound(TAG_PATTERN)) + val pat = HexPattern.fromNBT(nbt.getCompound(TAG_PATTERN)) var angleDesc = pat.anglesSignature() if (angleDesc.isNotBlank()) angleDesc = " $angleDesc"; val out = TextComponent("HexPattern(").withStyle(ChatFormatting.GOLD) @@ -267,11 +260,11 @@ class SpellDatum private constructor(val payload: T) { // Also encode the entity's name as a component for the benefit of the client const val TAG_ENTITY_NAME_CHEATY = "name" - fun IsValidType(checkee: T): Boolean = + fun isValidType(checkee: T): Boolean = ValidTypes.any { clazz -> clazz.isAssignableFrom(checkee.javaClass) } @JvmStatic - fun GetTagName(datumType: DatumType): String { + fun tagForType(datumType: DatumType): String { return when (datumType) { DatumType.ENTITY -> TAG_ENTITY DatumType.WIDGET -> TAG_WIDGET diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/SpellList.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/SpellList.kt index 8b7757d4..74b6e3e6 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/SpellList.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/SpellList.kt @@ -1,5 +1,9 @@ package at.petrak.hexcasting.api.spell +import net.minecraft.nbt.CompoundTag +import net.minecraft.nbt.ListTag +import net.minecraft.server.level.ServerLevel + /** * Restricted interface for functional lists. * @@ -73,4 +77,16 @@ sealed class SpellList: Iterable> { return car } } + + companion object { + @JvmStatic + fun fromNBT(nbt: ListTag, world: ServerLevel): LList { + val out = ArrayList>(nbt.size) + for (subtag in nbt) { + // this is safe because otherwise we wouldn't have been able to get the list before + out.add(SpellDatum.fromNBT(subtag as CompoundTag, world)) + } + return LList(0, out) + } + } } 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 4d3e8b0f..245306d6 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 @@ -6,7 +6,7 @@ import at.petrak.hexcasting.api.spell.Operator import at.petrak.hexcasting.api.spell.mishaps.MishapEntityTooFarAway import at.petrak.hexcasting.api.spell.mishaps.MishapEvalTooDeep import at.petrak.hexcasting.api.spell.mishaps.MishapLocationTooFarAway -import at.petrak.hexcasting.api.utils.HexUtils +import at.petrak.hexcasting.api.utils.otherHand import at.petrak.hexcasting.xplat.IXplatAbstractions import net.minecraft.core.BlockPos import net.minecraft.server.level.ServerLevel @@ -33,7 +33,7 @@ data class CastingContext( private var depth: Int = 0 val world: ServerLevel get() = caster.getLevel() - val otherHand: InteractionHand get() = HexUtils.OtherHand(this.castingHand) + val otherHand: InteractionHand get() = otherHand(this.castingHand) val position: Vec3 get() = caster.position() private val entitiesGivenMotion = mutableSetOf() 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 5dbac676..ae2ebeb6 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 @@ -450,7 +450,7 @@ class CastingHarness private constructor( out.put(TAG_PARENTHESIZED, parensTag) if (this.prepackagedColorizer != null) { - out.put(TAG_PREPACKAGED_COLORIZER, this.prepackagedColorizer.serialize()) + out.put(TAG_PREPACKAGED_COLORIZER, this.prepackagedColorizer.serializeToNBT()) } return out @@ -466,18 +466,18 @@ class CastingHarness private constructor( const val TAG_PREPACKAGED_COLORIZER = "prepackaged_colorizer" @JvmStatic - fun DeserializeFromNBT(nbt: CompoundTag, ctx: CastingContext): CastingHarness { + fun fromNBT(nbt: CompoundTag, ctx: CastingContext): CastingHarness { return try { val stack = mutableListOf>() val stackTag = nbt.getList(TAG_STACK, Tag.TAG_COMPOUND) for (subtag in stackTag) { - val datum = SpellDatum.DeserializeFromNBT(subtag.asCompound, ctx.world) + val datum = SpellDatum.fromNBT(subtag.asCompound, ctx.world) stack.add(datum) } val localTag = nbt.getCompound(TAG_LOCAL) val localIota = - if (localTag.size() == 1) SpellDatum.DeserializeFromNBT(localTag, ctx.world) else SpellDatum.make( + if (localTag.size() == 1) SpellDatum.fromNBT(localTag, ctx.world) else SpellDatum.make( Widget.NULL ) @@ -485,16 +485,16 @@ class CastingHarness private constructor( val parenTag = nbt.getList(TAG_PARENTHESIZED, Tag.TAG_COMPOUND) for (subtag in parenTag) { if (subtag.asCompound.size() != 1) - parenthesized.add(SpellDatum.make(HexPattern.DeserializeFromNBT(subtag.asCompound))) + parenthesized.add(SpellDatum.make(HexPattern.fromNBT(subtag.asCompound))) else - parenthesized.add(SpellDatum.DeserializeFromNBT(subtag.asCompound, ctx.world)) + parenthesized.add(SpellDatum.fromNBT(subtag.asCompound, ctx.world)) } val parenCount = nbt.getInt(TAG_PAREN_COUNT) val escapeNext = nbt.getBoolean(TAG_ESCAPE_NEXT) val colorizer = if (nbt.contains(TAG_PREPACKAGED_COLORIZER)) { - FrozenColorizer.deserialize(nbt.getCompound(TAG_PREPACKAGED_COLORIZER)) + FrozenColorizer.fromNBT(nbt.getCompound(TAG_PREPACKAGED_COLORIZER)) } else { null } diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/ContinuationFrame.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/ContinuationFrame.kt index 672ca7be..08f7c5d2 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/ContinuationFrame.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/ContinuationFrame.kt @@ -3,6 +3,12 @@ package at.petrak.hexcasting.api.spell.casting import at.petrak.hexcasting.api.spell.SpellDatum import at.petrak.hexcasting.api.spell.SpellList import at.petrak.hexcasting.api.spell.casting.CastingHarness.CastResult +import at.petrak.hexcasting.api.utils.NBTBuilder +import at.petrak.hexcasting.api.utils.getList +import at.petrak.hexcasting.api.utils.hasList +import at.petrak.hexcasting.api.utils.serializeToNBT +import net.minecraft.nbt.CompoundTag +import net.minecraft.nbt.Tag import net.minecraft.server.level.ServerLevel /** @@ -32,6 +38,11 @@ sealed interface ContinuationFrame { */ fun breakDownwards(stack: List>): Pair>> + /** + * Serializes this frame. Used for things like delays, where we pause execution. + */ + fun serializeToNBT(): CompoundTag + /** * A list of patterns to be evaluated in sequence. * @property list the *remaining* list of patterns to be evaluated @@ -60,13 +71,19 @@ sealed interface ContinuationFrame { } } + override fun serializeToNBT(): CompoundTag { + return NBTBuilder { + "type" %= "evaluate" + "patterns" %= list.serializeToNBT() + } + } } /** * A stack marker representing the end of a Hermes evaluation, * so that we know when to stop removing frames during a Halt. */ - class FinishEval() : ContinuationFrame { + object FinishEval : ContinuationFrame { // Don't do anything else to the stack, just finish the halt statement. override fun breakDownwards(stack: List>) = Pair(true, stack) @@ -83,6 +100,10 @@ sealed interface ContinuationFrame { listOf() ) } + + override fun serializeToNBT() = NBTBuilder { + "type" %= "end" + } } /** @@ -148,5 +169,31 @@ sealed interface ContinuationFrame { listOf() ) } + + override fun serializeToNBT() = NBTBuilder { + "type" %= "foreach" + "data" %= data.serializeToNBT() + "code" %= code.serializeToNBT() + if (baseStack != null) + "base" %= baseStack.serializeToNBT() + "accumulator" %= acc.serializeToNBT() + } + } + + companion object { + @JvmStatic + fun fromNBT(tag: CompoundTag, world: ServerLevel): ContinuationFrame { + return when (tag.getString("type")) { + "eval" -> Evaluate(SpellList.fromNBT(tag.getList("patterns", Tag.TAG_COMPOUND), world)) + "end" -> FinishEval + "foreach" -> ForEach( + SpellList.fromNBT(tag.getList("data", Tag.TAG_COMPOUND), world), + SpellList.fromNBT(tag.getList("code", Tag.TAG_COMPOUND), world), + if (tag.hasList("base", Tag.TAG_COMPOUND)) SpellList.fromNBT(tag.getList("base", Tag.TAG_COMPOUND), world).toList() else null, + SpellList.fromNBT(tag.getList("accumulator", Tag.TAG_COMPOUND), world).toMutableList() + ) + else -> Evaluate(SpellList.LList(0, listOf())); + } + } } } diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/ResolvedPattern.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/ResolvedPattern.kt index c7414fcc..959582c8 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/ResolvedPattern.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/ResolvedPattern.kt @@ -18,8 +18,8 @@ data class ResolvedPattern(val pattern: HexPattern, val origin: HexCoord, var ty companion object { @JvmStatic - fun DeserializeFromNBT(tag: CompoundTag): ResolvedPattern { - val pattern = HexPattern.DeserializeFromNBT(tag.getCompound("Pattern")) + fun fromNBT(tag: CompoundTag): ResolvedPattern { + val pattern = HexPattern.fromNBT(tag.getCompound("Pattern")) val origin = HexCoord(tag.getInt("OriginQ"), tag.getInt("OriginR")) val valid = try { ResolvedPatternType.valueOf(tag.getString("Valid").uppercase(Locale.ROOT)) diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/SpellCircleContext.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/SpellCircleContext.kt index 5a23a7e7..a49f23e4 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/SpellCircleContext.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/casting/SpellCircleContext.kt @@ -39,7 +39,7 @@ data class SpellCircleContext(val impetusPos: BlockPos, val aabb: AABB, val acti const val TAG_MAX_Z = "max_z" const val TAG_PLAYER_ALWAYS_IN_RANGE = "player_always_in_range" - fun DeserializeFromNBT(tag: CompoundTag): SpellCircleContext { + fun fromNBT(tag: CompoundTag): SpellCircleContext { val impX = tag.getInt(TAG_IMPETUS_X) val impY = tag.getInt(TAG_IMPETUS_Y) val impZ = tag.getInt(TAG_IMPETUS_Z) diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/math/HexPattern.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/math/HexPattern.kt index aa578944..dabf2756 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/math/HexPattern.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/math/HexPattern.kt @@ -1,6 +1,7 @@ package at.petrak.hexcasting.api.spell.math -import at.petrak.hexcasting.api.utils.HexUtils +import at.petrak.hexcasting.api.utils.findCenter +import at.petrak.hexcasting.api.utils.coordToPx import net.minecraft.nbt.ByteArrayTag import net.minecraft.nbt.ByteTag import net.minecraft.nbt.CompoundTag @@ -103,9 +104,9 @@ data class HexPattern(public val startDir: HexDir, public val angles: MutableLis */ @JvmOverloads fun getCenter(hexRadius: Float, origin: HexCoord = HexCoord.Origin): Vec2 { - val originPx = HexUtils.coordToPx(origin, hexRadius, Vec2.ZERO) + val originPx = coordToPx(origin, hexRadius, Vec2.ZERO) val points = this.toLines(hexRadius, originPx) - return HexUtils.FindCenter(points) + return findCenter(points) } @@ -113,7 +114,7 @@ data class HexPattern(public val startDir: HexDir, public val angles: MutableLis * Convert a hex pattern into a sequence of straight linePoints spanning its points. */ fun toLines(hexSize: Float, origin: Vec2): List = - this.positions().map { HexUtils.coordToPx(it, hexSize, origin) } + this.positions().map { coordToPx(it, hexSize, origin) } override fun toString(): String = buildString { append("HexPattern[") @@ -128,7 +129,7 @@ data class HexPattern(public val startDir: HexDir, public val angles: MutableLis const val TAG_ANGLES = "angles" @JvmStatic - fun IsHexPattern(tag: CompoundTag): Boolean { + fun isPattern(tag: CompoundTag): Boolean { return tag.contains(TAG_START_DIR, Tag.TAG_ANY_NUMERIC.toInt()) && tag.contains( TAG_ANGLES, Tag.TAG_BYTE_ARRAY.toInt() @@ -136,14 +137,14 @@ data class HexPattern(public val startDir: HexDir, public val angles: MutableLis } @JvmStatic - fun DeserializeFromNBT(tag: CompoundTag): HexPattern { + fun fromNBT(tag: CompoundTag): HexPattern { val startDir = HexDir.values()[tag.getByte(TAG_START_DIR).toInt()] val angles = tag.getByteArray(TAG_ANGLES).map { HexAngle.values()[it.toInt()] } return HexPattern(startDir, angles.toMutableList()) } @JvmStatic - fun FromAnglesSig(signature: String, startDir: HexDir): HexPattern { + fun fromAngles(signature: String, startDir: HexDir): HexPattern { val out = HexPattern(startDir) var compass = startDir diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapAlreadyBrainswept.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapAlreadyBrainswept.kt index 2965f923..9928c36d 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapAlreadyBrainswept.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapAlreadyBrainswept.kt @@ -18,7 +18,7 @@ class MishapAlreadyBrainswept(val villager: Villager) : Mishap() { } override fun particleSpray(ctx: CastingContext): ParticleSpray { - return ParticleSpray.Burst(villager.eyePosition, 1.0) + return ParticleSpray.burst(villager.eyePosition, 1.0) } override fun errorMessage(ctx: CastingContext, errorCtx: Context): Component = diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadBlock.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadBlock.kt index a2f6c2be..5da84097 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadBlock.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadBlock.kt @@ -20,7 +20,7 @@ class MishapBadBlock(val pos: BlockPos, val expected: Component) : Mishap() { } override fun particleSpray(ctx: CastingContext): ParticleSpray { - return ParticleSpray.Burst(Vec3.atCenterOf(pos), 1.0) + return ParticleSpray.burst(Vec3.atCenterOf(pos), 1.0) } override fun errorMessage(ctx: CastingContext, errorCtx: Context): Component { diff --git a/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadBrainsweep.kt b/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadBrainsweep.kt index 737884b2..fbf5c1d3 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadBrainsweep.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadBrainsweep.kt @@ -20,7 +20,7 @@ class MishapBadBrainsweep(val villager: Villager, val pos: BlockPos) : Mishap() } override fun particleSpray(ctx: CastingContext): ParticleSpray { - return ParticleSpray.Burst(Vec3.atCenterOf(pos), 1.0) + return ParticleSpray.burst(Vec3.atCenterOf(pos), 1.0) } override fun errorMessage(ctx: CastingContext, errorCtx: Context): Component { diff --git a/Common/src/main/java/at/petrak/hexcasting/api/utils/HexUtils.kt b/Common/src/main/java/at/petrak/hexcasting/api/utils/HexUtils.kt index ec465c23..e5bf298f 100644 --- a/Common/src/main/java/at/petrak/hexcasting/api/utils/HexUtils.kt +++ b/Common/src/main/java/at/petrak/hexcasting/api/utils/HexUtils.kt @@ -1,7 +1,10 @@ +@file:JvmName("HexUtils") package at.petrak.hexcasting.api.utils +import at.petrak.hexcasting.api.spell.SpellDatum import at.petrak.hexcasting.api.spell.math.HexCoord import net.minecraft.nbt.CompoundTag +import net.minecraft.nbt.ListTag import net.minecraft.nbt.LongArrayTag import net.minecraft.world.InteractionHand import net.minecraft.world.item.ItemStack @@ -12,88 +15,82 @@ import kotlin.math.max import kotlin.math.min import kotlin.math.roundToInt -object HexUtils { - const val SQRT_3 = 1.7320508f +const val TAU = Math.PI * 2.0 +const val SQRT_3 = 1.7320508f - @JvmStatic - fun Vec3.serializeToNBT(): LongArrayTag = - LongArrayTag(longArrayOf(this.x.toRawBits(), this.y.toRawBits(), this.z.toRawBits())) +fun Vec3.serializeToNBT(): LongArrayTag = + LongArrayTag(longArrayOf(this.x.toRawBits(), this.y.toRawBits(), this.z.toRawBits())) - @JvmStatic - fun DeserializeVec3FromNBT(tag: LongArray): Vec3 = if (tag.size != 3) Vec3.ZERO else - Vec3( - Double.fromBits(tag[0]), - Double.fromBits(tag[1]), - Double.fromBits(tag[2]) - ) +fun vecFromNBT(tag: LongArray): Vec3 = if (tag.size != 3) Vec3.ZERO else + Vec3( + Double.fromBits(tag[0]), + Double.fromBits(tag[1]), + Double.fromBits(tag[2]) + ) - @JvmStatic - fun Vec2.serializeToNBT(): LongArrayTag = - LongArrayTag(longArrayOf(this.x.toDouble().toRawBits(), this.y.toDouble().toRawBits())) +fun Vec2.serializeToNBT(): LongArrayTag = + LongArrayTag(longArrayOf(this.x.toDouble().toRawBits(), this.y.toDouble().toRawBits())) - @JvmStatic - fun DeserializeVec2FromNBT(tag: LongArray): Vec2 = if (tag.size != 2) Vec2.ZERO else - Vec2( - Double.fromBits(tag[0]).toFloat(), - Double.fromBits(tag[1]).toFloat(), - ) +fun vec2FromNBT(tag: LongArray): Vec2 = if (tag.size != 2) Vec2.ZERO else + Vec2( + Double.fromBits(tag[0]).toFloat(), + Double.fromBits(tag[1]).toFloat(), + ) - @JvmStatic - fun OtherHand(hand: InteractionHand) = - if (hand == InteractionHand.MAIN_HAND) InteractionHand.OFF_HAND else InteractionHand.MAIN_HAND +fun otherHand(hand: InteractionHand) = + if (hand == InteractionHand.MAIN_HAND) InteractionHand.OFF_HAND else InteractionHand.MAIN_HAND - @JvmStatic - fun FixNANs(x: Double): Double = if (x.isFinite()) x else 0.0 +fun fixNAN(x: Double): Double = if (x.isFinite()) x else 0.0 - @JvmStatic - fun FindCenter(points: List): Vec2 { - var minX = Float.POSITIVE_INFINITY - var minY = Float.POSITIVE_INFINITY - var maxX = Float.NEGATIVE_INFINITY - var maxY = Float.NEGATIVE_INFINITY +fun findCenter(points: List): Vec2 { + var minX = Float.POSITIVE_INFINITY + var minY = Float.POSITIVE_INFINITY + var maxX = Float.NEGATIVE_INFINITY + var maxY = Float.NEGATIVE_INFINITY - for (pos in points) { - minX = min(minX, pos.x) - minY = min(minY, pos.y) - maxX = max(maxX, pos.x) - maxY = max(maxY, pos.y) - } - return Vec2( - (minX + maxX) / 2f, - (minY + maxY) / 2f - ) - } - - @JvmStatic - fun coordToPx(coord: HexCoord, size: Float, offset: Vec2) = - Vec2( - SQRT_3 * coord.q.toFloat() + SQRT_3 / 2.0f * coord.r.toFloat(), - 1.5f * coord.r.toFloat() - ).scale(size).add(offset) - - @JvmStatic - fun pxToCoord(px: Vec2, size: Float, offset: Vec2): HexCoord { - val offsetted = px.add(offset.negated()) - var qf = (SQRT_3 / 3.0f * offsetted.x - 0.33333f * offsetted.y) / size - var rf = (0.66666f * offsetted.y) / size - - val q = qf.roundToInt() - val r = rf.roundToInt() - qf -= q - rf -= r - return if (q.absoluteValue >= r.absoluteValue) - HexCoord(q + (qf + 0.5f * rf).roundToInt(), r) - else - HexCoord(q, r + (rf + 0.5 * qf).roundToInt()) - } - - const val TAU = Math.PI * 2.0 - - // Copy the impl from forge - @JvmStatic - fun ItemStack.serialize(): CompoundTag { - val out = CompoundTag() - this.save(out) - return out + for (pos in points) { + minX = min(minX, pos.x) + minY = min(minY, pos.y) + maxX = max(maxX, pos.x) + maxY = max(maxY, pos.y) } + return Vec2( + (minX + maxX) / 2f, + (minY + maxY) / 2f + ) +} + +fun coordToPx(coord: HexCoord, size: Float, offset: Vec2): Vec2 = + Vec2( + SQRT_3 * coord.q.toFloat() + SQRT_3 / 2.0f * coord.r.toFloat(), + 1.5f * coord.r.toFloat() + ).scale(size).add(offset) + +fun pxToCoord(px: Vec2, size: Float, offset: Vec2): HexCoord { + val offsetted = px.add(offset.negated()) + var qf = (SQRT_3 / 3.0f * offsetted.x - 0.33333f * offsetted.y) / size + var rf = (0.66666f * offsetted.y) / size + + val q = qf.roundToInt() + val r = rf.roundToInt() + qf -= q + rf -= r + return if (q.absoluteValue >= r.absoluteValue) + HexCoord(q + (qf + 0.5f * rf).roundToInt(), r) + else + HexCoord(q, r + (rf + 0.5 * qf).roundToInt()) +} + +fun Iterable>.serializeToNBT(): ListTag { + val tag = ListTag() + for (elt in this) + tag.add(elt.serializeToNBT()) + return tag +} + +// Copy the impl from forge +fun ItemStack.serializeToNBT(): CompoundTag { + val out = CompoundTag() + this.save(out) + return out } diff --git a/Common/src/main/java/at/petrak/hexcasting/api/utils/NBTDsl.kt b/Common/src/main/java/at/petrak/hexcasting/api/utils/NBTDsl.kt new file mode 100644 index 00000000..dceff199 --- /dev/null +++ b/Common/src/main/java/at/petrak/hexcasting/api/utils/NBTDsl.kt @@ -0,0 +1,185 @@ +@file:Suppress("NOTHING_TO_INLINE") +package at.petrak.hexcasting.api.utils + +import net.minecraft.nbt.* + +// https://github.com/TeamWizardry/LibrarianLib/blob/9cfb2cf3e35685568942ad41395265a2edc27d30/modules/core/src/main/kotlin/com/teamwizardry/librarianlib/core/util/kotlin/NbtBuilder.kt + +@DslMarker +internal annotation class NBTDslMarker + +@NBTDslMarker +object NBTBuilder { + inline operator fun invoke(block: NbtCompoundBuilder.() -> Unit) = compound(block) + + inline fun use(tag: CompoundTag, block: NbtCompoundBuilder.() -> Unit): CompoundTag = + NbtCompoundBuilder(tag).also(block).tag + + inline fun compound(block: NbtCompoundBuilder.() -> Unit): CompoundTag = + NbtCompoundBuilder(CompoundTag()).also(block).tag + + inline fun list(block: NbtListBuilder.() -> Unit): ListTag = + NbtListBuilder(ListTag()).also(block).tag + + inline fun list(vararg elements: Tag, block: NbtListBuilder.() -> Unit): ListTag = + NbtListBuilder(ListTag()).also { + it.addAll(elements.toList()) + it.block() + }.tag + + inline fun list(vararg elements: Tag): ListTag = ListTag().also { it.addAll(elements) } + inline fun list(elements: Collection): ListTag = ListTag().also { it.addAll(elements) } + + inline fun double(value: Number): DoubleTag = DoubleTag.valueOf(value.toDouble()) + inline fun float(value: Number): FloatTag = FloatTag.valueOf(value.toFloat()) + inline fun long(value: Number): LongTag = LongTag.valueOf(value.toLong()) + inline fun int(value: Number): IntTag = IntTag.valueOf(value.toInt()) + inline fun short(value: Number): ShortTag = ShortTag.valueOf(value.toShort()) + inline fun byte(value: Number): ByteTag = ByteTag.valueOf(value.toByte()) + + inline fun string(value: String): StringTag = StringTag.valueOf(value) + + inline fun byteArray(vararg value: Int): ByteArrayTag = ByteArrayTag(ByteArray(value.size) { value[it].toByte() }) + inline fun byteArray(vararg value: Byte): ByteArrayTag = ByteArrayTag(value) + inline fun byteArray(): ByteArrayTag = ByteArrayTag(byteArrayOf()) // avoiding overload ambiguity + inline fun longArray(vararg value: Int): LongArrayTag = LongArrayTag(LongArray(value.size) { value[it].toLong() }) + inline fun longArray(vararg value: Long): LongArrayTag = LongArrayTag(value) + inline fun longArray(): LongArrayTag = LongArrayTag(longArrayOf()) // avoiding overload ambiguity + inline fun intArray(vararg value: Int): IntArrayTag = IntArrayTag(value) +} + +@JvmInline +@NBTDslMarker +value class NbtCompoundBuilder(val tag: CompoundTag) { + // configuring this tag + + inline operator fun String.remAssign(nbt: Tag) { + tag.put(this, nbt) + } + + inline operator fun String.remAssign(str: String) { + tag.put(this, string(str)) + } + + inline operator fun String.remAssign(num: Int) { + tag.put(this, int(num)) + } + + // creating new tags + + inline fun compound(block: NbtCompoundBuilder.() -> Unit): CompoundTag = + NbtCompoundBuilder(CompoundTag()).also { it.block() }.tag + + inline fun list(block: NbtListBuilder.() -> Unit): ListTag = + NbtListBuilder(ListTag()).also { it.block() }.tag + + inline fun list(vararg elements: Tag, block: NbtListBuilder.() -> Unit): ListTag = + NbtListBuilder(ListTag()).also { + it.addAll(elements.toList()) + it.block() + }.tag + + inline fun list(vararg elements: Tag): ListTag = ListTag().also { it.addAll(elements) } + inline fun list(elements: Collection): ListTag = ListTag().also { it.addAll(elements) } + + inline fun double(value: Number): DoubleTag = DoubleTag.valueOf(value.toDouble()) + inline fun float(value: Number): FloatTag = FloatTag.valueOf(value.toFloat()) + inline fun long(value: Number): LongTag = LongTag.valueOf(value.toLong()) + inline fun int(value: Number): IntTag = IntTag.valueOf(value.toInt()) + inline fun short(value: Number): ShortTag = ShortTag.valueOf(value.toShort()) + inline fun byte(value: Number): ByteTag = ByteTag.valueOf(value.toByte()) + + inline fun string(value: String): StringTag = StringTag.valueOf(value) + + inline fun byteArray(vararg value: Int): ByteArrayTag = ByteArrayTag(ByteArray(value.size) { value[it].toByte() }) + inline fun byteArray(vararg value: Byte): ByteArrayTag = ByteArrayTag(value) + inline fun byteArray(): ByteArrayTag = ByteArrayTag(byteArrayOf()) // avoiding overload ambiguity + inline fun longArray(vararg value: Int): LongArrayTag = LongArrayTag(LongArray(value.size) { value[it].toLong() }) + inline fun longArray(vararg value: Long): LongArrayTag = LongArrayTag(value) + inline fun longArray(): LongArrayTag = LongArrayTag(longArrayOf()) // avoiding overload ambiguity + inline fun intArray(vararg value: Int): IntArrayTag = IntArrayTag(value) +} + +@JvmInline +@NBTDslMarker +value class NbtListBuilder(val tag: ListTag) { + // configuring this tag + + /** + * Add the given Tag<* tag to this list + */ + operator fun Tag.unaryPlus() { + tag.add(this) + } + + /** + * Add the given Tag<* tags to this list + */ + operator fun Collection.unaryPlus() { + tag.addAll(this) + } + + /** + * Add the given Tag<* tag to this list. This is explicitly defined for [ListTag] because otherwise there is overload + * ambiguity between the [Tag<*] and [Collection]<[Tag<*]> methods. + */ + operator fun ListTag.unaryPlus() { + tag.add(this) + } + + fun addAll(nbt: Collection) { + this.tag.addAll(nbt) + } + + fun add(nbt: Tag) { + this.tag.add(nbt) + } + + // creating new tags + + inline fun compound(block: NbtCompoundBuilder.() -> Unit): CompoundTag = + NbtCompoundBuilder(CompoundTag()).also { it.block() }.tag + + inline fun list(block: NbtListBuilder.() -> Unit): ListTag = + NbtListBuilder(ListTag()).also { it.block() }.tag + + inline fun list(vararg elements: Tag, block: NbtListBuilder.() -> Unit): ListTag = + NbtListBuilder(ListTag()).also { + it.addAll(elements.toList()) + it.block() + }.tag + + inline fun list(vararg elements: Tag): ListTag = ListTag().also { it.addAll(elements) } + inline fun list(elements: Collection): ListTag = ListTag().also { it.addAll(elements) } + + inline fun double(value: Number): DoubleTag = DoubleTag.valueOf(value.toDouble()) + inline fun float(value: Number): FloatTag = FloatTag.valueOf(value.toFloat()) + inline fun long(value: Number): LongTag = LongTag.valueOf(value.toLong()) + inline fun int(value: Number): IntTag = IntTag.valueOf(value.toInt()) + inline fun short(value: Number): ShortTag = ShortTag.valueOf(value.toShort()) + inline fun byte(value: Number): ByteTag = ByteTag.valueOf(value.toByte()) + + inline fun string(value: String): StringTag = StringTag.valueOf(value) + + inline fun byteArray(vararg value: Int): ByteArrayTag = ByteArrayTag(ByteArray(value.size) { value[it].toByte() }) + inline fun byteArray(vararg value: Byte): ByteArrayTag = ByteArrayTag(value) + inline fun byteArray(): ByteArrayTag = ByteArrayTag(byteArrayOf()) // avoiding overload ambiguity + inline fun longArray(vararg value: Int): LongArrayTag = LongArrayTag(LongArray(value.size) { value[it].toLong() }) + inline fun longArray(vararg value: Long): LongArrayTag = LongArrayTag(value) + inline fun longArray(): LongArrayTag = LongArrayTag(longArrayOf()) // avoiding overload ambiguity + inline fun intArray(vararg value: Int): IntArrayTag = IntArrayTag(value) + + inline fun doubles(vararg value: Int): List = value.map { DoubleTag.valueOf(it.toDouble()) } + inline fun doubles(vararg value: Double): List = value.map { DoubleTag.valueOf(it) } + inline fun floats(vararg value: Int): List = value.map { FloatTag.valueOf(it.toFloat()) } + inline fun floats(vararg value: Float): List = value.map { FloatTag.valueOf(it) } + inline fun longs(vararg value: Int): List = value.map { LongTag.valueOf(it.toLong()) } + inline fun longs(vararg value: Long): List = value.map { LongTag.valueOf(it) } + inline fun ints(vararg value: Int): List = value.map { IntTag.valueOf(it) } + inline fun shorts(vararg value: Int): List = value.map { ShortTag.valueOf(it.toShort()) } + inline fun shorts(vararg value: Short): List = value.map { ShortTag.valueOf(it) } + inline fun bytes(vararg value: Int): List = value.map { ByteTag.valueOf(it.toByte()) } + inline fun bytes(vararg value: Byte): List = value.map { ByteTag.valueOf(it) } + + fun strings(vararg value: String): List = value.map { StringTag.valueOf(it) } +} diff --git a/Common/src/main/java/at/petrak/hexcasting/client/RenderLib.kt b/Common/src/main/java/at/petrak/hexcasting/client/RenderLib.kt index 57d5cf93..3b31da51 100644 --- a/Common/src/main/java/at/petrak/hexcasting/client/RenderLib.kt +++ b/Common/src/main/java/at/petrak/hexcasting/client/RenderLib.kt @@ -2,7 +2,7 @@ package at.petrak.hexcasting.client import at.petrak.hexcasting.api.mod.HexConfig import at.petrak.hexcasting.api.spell.math.HexPattern -import at.petrak.hexcasting.api.utils.HexUtils +import at.petrak.hexcasting.api.utils.TAU import com.mojang.blaze3d.systems.RenderSystem import com.mojang.blaze3d.vertex.DefaultVertexFormat import com.mojang.blaze3d.vertex.PoseStack @@ -191,7 +191,7 @@ object RenderLib { // as well as some random variance... // (We use i, j (segment #, subsegment #) as seeds for the Perlin noise, // and zSeed (i.e. time elapsed) to perturb the shape gradually over time) - val theta = (3 * NOISE.getValue(i.toDouble(), j.toDouble(), zSeed) * HexUtils.TAU).toFloat() + val theta = (3 * NOISE.getValue(i.toDouble(), j.toDouble(), zSeed) * TAU).toFloat() val r = NOISE.getValue(i.inv().toDouble(), j.toDouble(), zSeed).toFloat() * maxVariance val randomHop = Vec2(r * Mth.cos(theta), r * Mth.sin(theta)) position = position.add(hop).add(randomHop) @@ -223,7 +223,7 @@ object RenderLib { val fracOfCircle = 6 // run 0 AND last; this way the circle closes for (i in 0..fracOfCircle) { - val theta = i.toFloat() / fracOfCircle * HexUtils.TAU.toFloat() + val theta = i.toFloat() / fracOfCircle * TAU.toFloat() val rx = Mth.cos(theta) * radius + point.x val ry = Mth.sin(theta) * radius + point.y buf.vertex(mat, rx, ry, 1f).color(r, g, b, a).endVertex() 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 3e091d46..cf5184f8 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 @@ -8,7 +8,7 @@ import at.petrak.hexcasting.api.spell.math.HexAngle 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.HexUtils +import at.petrak.hexcasting.api.utils.otherHand import at.petrak.hexcasting.client.RenderLib import at.petrak.hexcasting.client.sound.GridSoundInstance import at.petrak.hexcasting.common.items.ItemSpellbook @@ -231,7 +231,7 @@ class GuiSpellcasting( override fun mouseScrolled(pMouseX: Double, pMouseY: Double, pDelta: Double): Boolean { super.mouseScrolled(pMouseX, pMouseY, pDelta) - val otherHand = HexUtils.OtherHand(this.handOpenedWith) + val otherHand = otherHand(this.handOpenedWith) if (Minecraft.getInstance().player!!.getItemInHand(otherHand).item is ItemSpellbook) IClientXplatAbstractions.INSTANCE.sendPacketToServer( MsgShiftScrollSyn( @@ -338,7 +338,7 @@ class GuiSpellcasting( /** Distance between adjacent hex centers */ fun hexSize(): Float { val hasLens = Minecraft.getInstance().player!! - .getItemInHand(HexUtils.OtherHand(this.handOpenedWith)).`is`(HexItems.SCRYING_LENS) + .getItemInHand(otherHand(this.handOpenedWith)).`is`(HexItems.SCRYING_LENS) // Originally, we allowed 32 dots across. Assuming a 1920x1080 screen this allowed like 500-odd area. // Let's be generous and give them 512. @@ -348,8 +348,9 @@ class GuiSpellcasting( fun coordsOffset(): Vec2 = Vec2(this.width.toFloat() * 0.5f, this.height.toFloat() * 0.5f) - fun coordToPx(coord: HexCoord) = HexUtils.coordToPx(coord, this.hexSize(), this.coordsOffset()) - fun pxToCoord(px: Vec2) = HexUtils.pxToCoord(px, this.hexSize(), this.coordsOffset()) + fun coordToPx(coord: HexCoord) = + at.petrak.hexcasting.api.utils.coordToPx(coord, this.hexSize(), this.coordsOffset()) + fun pxToCoord(px: Vec2) = at.petrak.hexcasting.api.utils.pxToCoord(px, this.hexSize(), this.coordsOffset()) private sealed class PatternDrawState { diff --git a/Common/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockEntityAkashicBookshelf.java b/Common/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockEntityAkashicBookshelf.java index 521200fa..fb7ab89a 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockEntityAkashicBookshelf.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockEntityAkashicBookshelf.java @@ -70,8 +70,8 @@ public class BlockEntityAkashicBookshelf extends HexBlockEntity { } else { this.recordPos = null; } - if (HexPattern.IsHexPattern(pattern)) { - this.pattern = HexPattern.DeserializeFromNBT(pattern); + if (HexPattern.isPattern(pattern)) { + this.pattern = HexPattern.fromNBT(pattern); } else { this.pattern = null; } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockEntityAkashicRecord.java b/Common/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockEntityAkashicRecord.java index 87b5b41b..b770b82e 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockEntityAkashicRecord.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockEntityAkashicRecord.java @@ -81,14 +81,14 @@ public class BlockEntityAkashicRecord extends HexBlockEntity { if (entry == null) { return null; } else { - return SpellDatum.DeserializeFromNBT(entry.datum, slevel); + return SpellDatum.fromNBT(entry.datum, slevel); } } public Component getDisplayAt(HexPattern key) { var entry = this.entries.get(getKey(key)); if (entry != null) { - return SpellDatum.DisplayFromTag(entry.datum); + return SpellDatum.displayFromNBT(entry.datum); } else { return new TranslatableComponent("hexcasting.spelldata.akashic.nopos").withStyle(ChatFormatting.RED); } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/blocks/circles/BlockEntitySlate.java b/Common/src/main/java/at/petrak/hexcasting/common/blocks/circles/BlockEntitySlate.java index cd3b4337..e3822d0e 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/blocks/circles/BlockEntitySlate.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/blocks/circles/BlockEntitySlate.java @@ -32,8 +32,8 @@ public class BlockEntitySlate extends HexBlockEntity { protected void loadModData(CompoundTag tag) { if (tag.contains(TAG_PATTERN, Tag.TAG_COMPOUND)) { CompoundTag patternTag = tag.getCompound(TAG_PATTERN); - if (HexPattern.IsHexPattern(patternTag)) { - this.pattern = HexPattern.DeserializeFromNBT(patternTag); + if (HexPattern.isPattern(patternTag)) { + this.pattern = HexPattern.fromNBT(patternTag); } else { this.pattern = null; } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/blocks/entity/BlockEntityConjured.java b/Common/src/main/java/at/petrak/hexcasting/common/blocks/entity/BlockEntityConjured.java index 9364d8f1..319bfa81 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/blocks/entity/BlockEntityConjured.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/blocks/entity/BlockEntityConjured.java @@ -90,12 +90,12 @@ public class BlockEntityConjured extends HexBlockEntity { @Override protected void saveModData(CompoundTag tag) { - tag.put(TAG_COLORIZER, this.colorizer.serialize()); + tag.put(TAG_COLORIZER, this.colorizer.serializeToNBT()); } @Override protected void loadModData(CompoundTag tag) { - this.colorizer = FrozenColorizer.deserialize(tag.getCompound(TAG_COLORIZER)); + this.colorizer = FrozenColorizer.fromNBT(tag.getCompound(TAG_COLORIZER)); } public FrozenColorizer getColorizer() { diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/RegisterPatterns.java b/Common/src/main/java/at/petrak/hexcasting/common/casting/RegisterPatterns.java index 184efa84..23d08e1c 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/RegisterPatterns.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/RegisterPatterns.java @@ -16,7 +16,6 @@ import at.petrak.hexcasting.common.casting.operators.circles.OpCircleBounds; import at.petrak.hexcasting.common.casting.operators.circles.OpImpetusDir; import at.petrak.hexcasting.common.casting.operators.circles.OpImpetusPos; import at.petrak.hexcasting.common.casting.operators.eval.OpEval; -import at.petrak.hexcasting.common.casting.operators.eval.OpEvalDelay; import at.petrak.hexcasting.common.casting.operators.eval.OpForEach; import at.petrak.hexcasting.common.casting.operators.eval.OpHalt; import at.petrak.hexcasting.common.casting.operators.lists.*; @@ -52,417 +51,417 @@ public class RegisterPatterns { // - CW is the special or destruction version // == Getters == - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qaq", HexDir.NORTH_EAST), modLoc("get_caster"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qaq", HexDir.NORTH_EAST), modLoc("get_caster"), OpGetCaster.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aa", HexDir.EAST), modLoc("get_entity_pos"), + PatternRegistry.mapPattern(HexPattern.fromAngles("aa", HexDir.EAST), modLoc("get_entity_pos"), OpEntityPos.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wa", HexDir.EAST), modLoc("get_entity_look"), + PatternRegistry.mapPattern(HexPattern.fromAngles("wa", HexDir.EAST), modLoc("get_entity_look"), OpEntityLook.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("awq", HexDir.NORTH_EAST), modLoc("get_entity_height"), + PatternRegistry.mapPattern(HexPattern.fromAngles("awq", HexDir.NORTH_EAST), modLoc("get_entity_height"), OpEntityHeight.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wq", HexDir.EAST), modLoc("get_entity_velocity"), + PatternRegistry.mapPattern(HexPattern.fromAngles("wq", HexDir.EAST), modLoc("get_entity_velocity"), OpEntityVelocity.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wqaawdd", HexDir.EAST), modLoc("raycast"), + PatternRegistry.mapPattern(HexPattern.fromAngles("wqaawdd", HexDir.EAST), modLoc("raycast"), OpBlockRaycast.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("weddwaa", HexDir.EAST), modLoc("raycast/axis"), + PatternRegistry.mapPattern(HexPattern.fromAngles("weddwaa", HexDir.EAST), modLoc("raycast/axis"), OpBlockAxisRaycast.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("weaqa", HexDir.EAST), modLoc("raycast/entity"), + PatternRegistry.mapPattern(HexPattern.fromAngles("weaqa", HexDir.EAST), modLoc("raycast/entity"), OpEntityRaycast.INSTANCE); // == spell circle getters == - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eaqwqae", HexDir.SOUTH_WEST), + PatternRegistry.mapPattern(HexPattern.fromAngles("eaqwqae", HexDir.SOUTH_WEST), modLoc("circle/impetus_pos"), OpImpetusPos.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eaqwqaewede", HexDir.SOUTH_WEST), + PatternRegistry.mapPattern(HexPattern.fromAngles("eaqwqaewede", HexDir.SOUTH_WEST), modLoc("circle/impetus_dir"), OpImpetusDir.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eaqwqaewdd", HexDir.SOUTH_WEST), + PatternRegistry.mapPattern(HexPattern.fromAngles("eaqwqaewdd", HexDir.SOUTH_WEST), modLoc("circle/bounds/min"), new OpCircleBounds(false)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aqwqawaaqa", HexDir.WEST), + PatternRegistry.mapPattern(HexPattern.fromAngles("aqwqawaaqa", HexDir.WEST), modLoc("circle/bounds/max"), new OpCircleBounds(true)); // == Modify Stack == - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aadaa", HexDir.EAST), modLoc("duplicate"), + PatternRegistry.mapPattern(HexPattern.fromAngles("aadaa", HexDir.EAST), modLoc("duplicate"), OpDuplicate.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aadaadaa", HexDir.EAST), modLoc("duplicate_n"), + PatternRegistry.mapPattern(HexPattern.fromAngles("aadaadaa", HexDir.EAST), modLoc("duplicate_n"), OpDuplicateN.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qwaeawqaeaqa", HexDir.NORTH_WEST), modLoc("stack_len"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qwaeawqaeaqa", HexDir.NORTH_WEST), modLoc("stack_len"), OpStackSize.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aawdd", HexDir.EAST), modLoc("swap"), OpSwap.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("ddad", HexDir.WEST), modLoc("fisherman"), + PatternRegistry.mapPattern(HexPattern.fromAngles("aawdd", HexDir.EAST), modLoc("swap"), OpSwap.INSTANCE); + PatternRegistry.mapPattern(HexPattern.fromAngles("ddad", HexDir.WEST), modLoc("fisherman"), OpFisherman.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qaawdde", HexDir.SOUTH_EAST), modLoc("swizzle"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qaawdde", HexDir.SOUTH_EAST), modLoc("swizzle"), OpAlwinfyHasAscendedToABeingOfPureMath.INSTANCE); // == Math == - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("waaw", HexDir.NORTH_EAST), modLoc("add"), + PatternRegistry.mapPattern(HexPattern.fromAngles("waaw", HexDir.NORTH_EAST), modLoc("add"), OpAdd.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wddw", HexDir.NORTH_WEST), modLoc("sub"), + PatternRegistry.mapPattern(HexPattern.fromAngles("wddw", HexDir.NORTH_WEST), modLoc("sub"), OpSub.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("waqaw", HexDir.SOUTH_EAST), modLoc("mul_dot"), + PatternRegistry.mapPattern(HexPattern.fromAngles("waqaw", HexDir.SOUTH_EAST), modLoc("mul_dot"), OpMulDot.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wdedw", HexDir.NORTH_EAST), modLoc("div_cross"), + PatternRegistry.mapPattern(HexPattern.fromAngles("wdedw", HexDir.NORTH_EAST), modLoc("div_cross"), OpDivCross.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wqaqw", HexDir.NORTH_EAST), modLoc("abs_len"), + PatternRegistry.mapPattern(HexPattern.fromAngles("wqaqw", HexDir.NORTH_EAST), modLoc("abs_len"), OpAbsLen.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wedew", HexDir.NORTH_WEST), modLoc("pow_proj"), + PatternRegistry.mapPattern(HexPattern.fromAngles("wedew", HexDir.NORTH_WEST), modLoc("pow_proj"), OpPowProj.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("ewq", HexDir.EAST), modLoc("floor"), + PatternRegistry.mapPattern(HexPattern.fromAngles("ewq", HexDir.EAST), modLoc("floor"), OpFloor.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qwe", HexDir.EAST), modLoc("ceil"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qwe", HexDir.EAST), modLoc("ceil"), OpCeil.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eqqqqq", HexDir.EAST), modLoc("construct_vec"), + PatternRegistry.mapPattern(HexPattern.fromAngles("eqqqqq", HexDir.EAST), modLoc("construct_vec"), OpConstructVec.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qeeeee", HexDir.EAST), modLoc("deconstruct_vec"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qeeeee", HexDir.EAST), modLoc("deconstruct_vec"), OpDeconstructVec.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqaww", HexDir.NORTH_WEST), modLoc("coerce_axial"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqaww", HexDir.NORTH_WEST), modLoc("coerce_axial"), OpCoerceToAxial.INSTANCE); // == Logic == - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wdw", HexDir.NORTH_EAST), modLoc("and"), + PatternRegistry.mapPattern(HexPattern.fromAngles("wdw", HexDir.NORTH_EAST), modLoc("and"), OpBoolAnd.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("waw", HexDir.SOUTH_EAST), modLoc("or"), + PatternRegistry.mapPattern(HexPattern.fromAngles("waw", HexDir.SOUTH_EAST), modLoc("or"), OpBoolOr.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("dwa", HexDir.NORTH_WEST), modLoc("xor"), + PatternRegistry.mapPattern(HexPattern.fromAngles("dwa", HexDir.NORTH_WEST), modLoc("xor"), OpBoolXor.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("e", HexDir.SOUTH_EAST), modLoc("greater"), + PatternRegistry.mapPattern(HexPattern.fromAngles("e", HexDir.SOUTH_EAST), modLoc("greater"), new OpCompare(false, (a, b) -> a > b)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("q", HexDir.SOUTH_WEST), modLoc("less"), + PatternRegistry.mapPattern(HexPattern.fromAngles("q", HexDir.SOUTH_WEST), modLoc("less"), new OpCompare(false, (a, b) -> a < b)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("ee", HexDir.SOUTH_EAST), modLoc("greater_eq"), + PatternRegistry.mapPattern(HexPattern.fromAngles("ee", HexDir.SOUTH_EAST), modLoc("greater_eq"), new OpCompare(true, (a, b) -> a >= b)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qq", HexDir.SOUTH_WEST), modLoc("less_eq"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qq", HexDir.SOUTH_WEST), modLoc("less_eq"), new OpCompare(true, (a, b) -> a <= b)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("ad", HexDir.EAST), modLoc("equals"), + PatternRegistry.mapPattern(HexPattern.fromAngles("ad", HexDir.EAST), modLoc("equals"), new OpEquality(false)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("da", HexDir.EAST), modLoc("not_equals"), + PatternRegistry.mapPattern(HexPattern.fromAngles("da", HexDir.EAST), modLoc("not_equals"), new OpEquality(true)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("dw", HexDir.NORTH_WEST), modLoc("not"), + PatternRegistry.mapPattern(HexPattern.fromAngles("dw", HexDir.NORTH_WEST), modLoc("not"), OpBoolNot.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aw", HexDir.NORTH_EAST), modLoc("identity"), + PatternRegistry.mapPattern(HexPattern.fromAngles("aw", HexDir.NORTH_EAST), modLoc("identity"), OpBoolIdentityKindOf.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eqqq", HexDir.NORTH_WEST), modLoc("random"), + PatternRegistry.mapPattern(HexPattern.fromAngles("eqqq", HexDir.NORTH_WEST), modLoc("random"), OpRandom.INSTANCE); // == Advanced Math == - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqaa", HexDir.SOUTH_EAST), modLoc("sin"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqaa", HexDir.SOUTH_EAST), modLoc("sin"), OpSin.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqad", HexDir.SOUTH_EAST), modLoc("cos"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqad", HexDir.SOUTH_EAST), modLoc("cos"), OpCos.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wqqqqqadq", HexDir.SOUTH_WEST), modLoc("tan"), + PatternRegistry.mapPattern(HexPattern.fromAngles("wqqqqqadq", HexDir.SOUTH_WEST), modLoc("tan"), OpTan.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("ddeeeee", HexDir.SOUTH_EAST), modLoc("arcsin"), + PatternRegistry.mapPattern(HexPattern.fromAngles("ddeeeee", HexDir.SOUTH_EAST), modLoc("arcsin"), OpArcSin.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("adeeeee", HexDir.NORTH_EAST), modLoc("arccos"), + PatternRegistry.mapPattern(HexPattern.fromAngles("adeeeee", HexDir.NORTH_EAST), modLoc("arccos"), OpArcCos.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eadeeeeew", HexDir.NORTH_EAST), modLoc("arctan"), + PatternRegistry.mapPattern(HexPattern.fromAngles("eadeeeeew", HexDir.NORTH_EAST), modLoc("arctan"), OpArcTan.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eqaqe", HexDir.NORTH_WEST), modLoc("logarithm"), + PatternRegistry.mapPattern(HexPattern.fromAngles("eqaqe", HexDir.NORTH_WEST), modLoc("logarithm"), OpLog.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("addwaad", HexDir.NORTH_EAST), modLoc("modulo"), + PatternRegistry.mapPattern(HexPattern.fromAngles("addwaad", HexDir.NORTH_EAST), modLoc("modulo"), OpModulo.INSTANCE); // == Sets == - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wdweaqa", HexDir.NORTH_EAST), modLoc("and_bit"), + PatternRegistry.mapPattern(HexPattern.fromAngles("wdweaqa", HexDir.NORTH_EAST), modLoc("and_bit"), OpAnd.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("waweaqa", HexDir.SOUTH_EAST), modLoc("or_bit"), + PatternRegistry.mapPattern(HexPattern.fromAngles("waweaqa", HexDir.SOUTH_EAST), modLoc("or_bit"), OpOr.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("dwaeaqa", HexDir.NORTH_WEST), modLoc("xor_bit"), + PatternRegistry.mapPattern(HexPattern.fromAngles("dwaeaqa", HexDir.NORTH_WEST), modLoc("xor_bit"), OpXor.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("dweaqa", HexDir.NORTH_WEST), modLoc("not_bit"), + PatternRegistry.mapPattern(HexPattern.fromAngles("dweaqa", HexDir.NORTH_WEST), modLoc("not_bit"), OpNot.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aweaqa", HexDir.NORTH_EAST), modLoc("to_set"), + PatternRegistry.mapPattern(HexPattern.fromAngles("aweaqa", HexDir.NORTH_EAST), modLoc("to_set"), OpToSet.INSTANCE); // == Spells == - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("de", HexDir.NORTH_EAST), modLoc("print"), + PatternRegistry.mapPattern(HexPattern.fromAngles("de", HexDir.NORTH_EAST), modLoc("print"), OpPrint.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aawaawaa", HexDir.EAST), modLoc("explode"), + PatternRegistry.mapPattern(HexPattern.fromAngles("aawaawaa", HexDir.EAST), modLoc("explode"), new OpExplode(false)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("ddwddwdd", HexDir.EAST), modLoc("explode/fire"), + PatternRegistry.mapPattern(HexPattern.fromAngles("ddwddwdd", HexDir.EAST), modLoc("explode/fire"), new OpExplode(true)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("awqqqwaqw", HexDir.SOUTH_WEST), modLoc("add_motion"), + PatternRegistry.mapPattern(HexPattern.fromAngles("awqqqwaqw", HexDir.SOUTH_WEST), modLoc("add_motion"), OpAddMotion.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("awqqqwaq", HexDir.SOUTH_WEST), modLoc("blink"), + PatternRegistry.mapPattern(HexPattern.fromAngles("awqqqwaq", HexDir.SOUTH_WEST), modLoc("blink"), OpBlink.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qaqqqqq", HexDir.EAST), modLoc("break_block"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qaqqqqq", HexDir.EAST), modLoc("break_block"), OpBreakBlock.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eeeeede", HexDir.SOUTH_WEST), modLoc("place_block"), + PatternRegistry.mapPattern(HexPattern.fromAngles("eeeeede", HexDir.SOUTH_WEST), modLoc("place_block"), OpPlaceBlock.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("awddwqawqwawq", HexDir.EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("awddwqawqwawq", HexDir.EAST), modLoc("colorize"), OpColorize.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aqawqadaq", HexDir.SOUTH_EAST), modLoc("create_water"), + PatternRegistry.mapPattern(HexPattern.fromAngles("aqawqadaq", HexDir.SOUTH_EAST), modLoc("create_water"), OpCreateWater.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("dedwedade", HexDir.SOUTH_WEST), + PatternRegistry.mapPattern(HexPattern.fromAngles("dedwedade", HexDir.SOUTH_WEST), modLoc("destroy_water"), OpDestroyWater.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aaqawawa", HexDir.SOUTH_EAST), modLoc("ignite"), + PatternRegistry.mapPattern(HexPattern.fromAngles("aaqawawa", HexDir.SOUTH_EAST), modLoc("ignite"), OpIgnite.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("ddedwdwd", HexDir.SOUTH_WEST), modLoc("extinguish"), + PatternRegistry.mapPattern(HexPattern.fromAngles("ddedwdwd", HexDir.SOUTH_WEST), modLoc("extinguish"), OpExtinguish.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqa", HexDir.NORTH_EAST), modLoc("conjure_block"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqa", HexDir.NORTH_EAST), modLoc("conjure_block"), new OpConjure(false)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqd", HexDir.NORTH_EAST), modLoc("conjure_light"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqd", HexDir.NORTH_EAST), modLoc("conjure_light"), new OpConjure(true)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wqaqwawqaqw", HexDir.NORTH_EAST), modLoc("bonemeal"), + PatternRegistry.mapPattern(HexPattern.fromAngles("wqaqwawqaqw", HexDir.NORTH_EAST), modLoc("bonemeal"), OpTheOnlyReasonAnyoneDownloadedPsi.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqwaeaeaeaeaea", HexDir.NORTH_WEST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqwaeaeaeaeaea", HexDir.NORTH_WEST), modLoc("recharge"), OpRecharge.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qdqawwaww", HexDir.EAST), modLoc("erase"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qdqawwaww", HexDir.EAST), modLoc("erase"), new OpErase()); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wqaqwd", HexDir.NORTH_EAST), modLoc("edify"), + PatternRegistry.mapPattern(HexPattern.fromAngles("wqaqwd", HexDir.NORTH_EAST), modLoc("edify"), OpEdifySapling.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("adaa", HexDir.WEST), modLoc("beep"), + PatternRegistry.mapPattern(HexPattern.fromAngles("adaa", HexDir.WEST), modLoc("beep"), OpBeep.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("waqqqqq", HexDir.EAST), modLoc("craft/cypher"), + PatternRegistry.mapPattern(HexPattern.fromAngles("waqqqqq", HexDir.EAST), modLoc("craft/cypher"), new OpMakePackagedSpell<>(HexItems.CYPHER, ManaConstants.CRYSTAL_UNIT)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wwaqqqqqeaqeaeqqqeaeq", HexDir.EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("wwaqqqqqeaqeaeqqqeaeq", HexDir.EAST), modLoc("craft/trinket"), new OpMakePackagedSpell<>(HexItems.TRINKET, 5 * ManaConstants.CRYSTAL_UNIT)); PatternRegistry.mapPattern( - HexPattern.FromAnglesSig("wwaqqqqqeawqwqwqwqwqwwqqeadaeqqeqqeadaeqq", HexDir.EAST), + HexPattern.fromAngles("wwaqqqqqeawqwqwqwqwqwwqqeadaeqqeqqeadaeqq", HexDir.EAST), modLoc("craft/artifact"), new OpMakePackagedSpell<>(HexItems.ARTIFACT, 10 * ManaConstants.CRYSTAL_UNIT)); PatternRegistry.mapPattern( - HexPattern.FromAnglesSig("aqqqaqwwaqqqqqeqaqqqawwqwqwqwqwqw", HexDir.SOUTH_WEST), + HexPattern.fromAngles("aqqqaqwwaqqqqqeqaqqqawwqwqwqwqwqw", HexDir.SOUTH_WEST), modLoc("craft/battery"), OpMakeBattery.INSTANCE, true); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqaqwawaw", HexDir.NORTH_WEST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqaqwawaw", HexDir.NORTH_WEST), modLoc("potion/weakness"), new OpPotionEffect(MobEffects.WEAKNESS, ManaConstants.DUST_UNIT / 10, true, false, false)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqawwawawd", HexDir.WEST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqawwawawd", HexDir.WEST), modLoc("potion/levitation"), new OpPotionEffect(MobEffects.LEVITATION, ManaConstants.DUST_UNIT / 5, false, false, false)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqaewawawe", HexDir.SOUTH_WEST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqaewawawe", HexDir.SOUTH_WEST), modLoc("potion/wither"), new OpPotionEffect(MobEffects.WITHER, ManaConstants.DUST_UNIT, true, false, false)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqadwawaww", HexDir.SOUTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqadwawaww", HexDir.SOUTH_EAST), modLoc("potion/poison"), new OpPotionEffect(MobEffects.POISON, ManaConstants.DUST_UNIT / 3, true, false, false)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqadwawaw", HexDir.SOUTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqadwawaw", HexDir.SOUTH_EAST), modLoc("potion/slowness"), new OpPotionEffect(MobEffects.MOVEMENT_SLOWDOWN, ManaConstants.DUST_UNIT / 3, true, false, false)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqaawawaedd", HexDir.NORTH_WEST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqaawawaedd", HexDir.NORTH_WEST), modLoc("potion/regeneration"), new OpPotionEffect(MobEffects.REGENERATION, ManaConstants.DUST_UNIT, true, true, true), true); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqaawawaeqdd", HexDir.WEST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqaawawaeqdd", HexDir.WEST), modLoc("potion/night_vision"), new OpPotionEffect(MobEffects.NIGHT_VISION, ManaConstants.DUST_UNIT / 5, false, true, true), true); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqaawawaeqqdd", HexDir.SOUTH_WEST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqaawawaeqqdd", HexDir.SOUTH_WEST), modLoc("potion/absorption"), new OpPotionEffect(MobEffects.ABSORPTION, ManaConstants.DUST_UNIT, true, true, true), true); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qaawawaeqqqdd", HexDir.SOUTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qaawawaeqqqdd", HexDir.SOUTH_EAST), modLoc("potion/haste"), new OpPotionEffect(MobEffects.DIG_SPEED, ManaConstants.DUST_UNIT / 3, true, true, true), true); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aawawaeqqqqdd", HexDir.EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("aawawaeqqqqdd", HexDir.EAST), modLoc("potion/strength"), new OpPotionEffect(MobEffects.DAMAGE_BOOST, ManaConstants.DUST_UNIT / 3, true, true, true), true); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("waeawae", HexDir.EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("waeawae", HexDir.EAST), modLoc("sentinel/create"), new OpCreateSentinel(false)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qdwdqdw", HexDir.NORTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qdwdqdw", HexDir.NORTH_EAST), modLoc("sentinel/destroy"), OpDestroySentinel.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("waeawaede", HexDir.EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("waeawaede", HexDir.EAST), modLoc("sentinel/get_pos"), OpGetSentinelPos.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("waeawaedwa", HexDir.EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("waeawaedwa", HexDir.EAST), modLoc("sentinel/wayfind"), OpGetSentinelWayfind.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("waadwawdaaweewq", HexDir.EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("waadwawdaaweewq", HexDir.EAST), modLoc("lightning"), OpLightning.INSTANCE, true); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eawwaeawawaa", HexDir.NORTH_WEST), + PatternRegistry.mapPattern(HexPattern.fromAngles("eawwaeawawaa", HexDir.NORTH_WEST), modLoc("flight"), OpFlight.INSTANCE, true); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eaqawqadaqd", HexDir.EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("eaqawqadaqd", HexDir.EAST), modLoc("create_lava"), OpCreateLava.INSTANCE, true); PatternRegistry.mapPattern( - HexPattern.FromAnglesSig("wwwqqqwwwqqeqqwwwqqwqqdqqqqqdqq", HexDir.EAST), + HexPattern.fromAngles("wwwqqqwwwqqeqqwwwqqwqqdqqqqqdqq", HexDir.EAST), modLoc("teleport"), OpTeleport.INSTANCE, true); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("waeawaeqqqwqwqqwq", HexDir.EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("waeawaeqqqwqwqqwq", HexDir.EAST), modLoc("sentinel/create/great"), new OpCreateSentinel(true), true); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eeewwweeewwaqqddqdqd", HexDir.EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("eeewwweeewwaqqddqdqd", HexDir.EAST), modLoc("dispel_rain"), new OpWeather(false), true); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wwweeewwweewdawdwad", HexDir.WEST), + PatternRegistry.mapPattern(HexPattern.fromAngles("wwweeewwweewdawdwad", HexDir.WEST), modLoc("summon_rain"), new OpWeather(true), true); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qeqwqwqwqwqeqaeqeaqeqaeqaqded", HexDir.NORTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qeqwqwqwqwqeqaeqeaqeqaeqaqded", HexDir.NORTH_EAST), modLoc("brainsweep"), OpBrainsweep.INSTANCE, true); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqwqqqqqaq", HexDir.WEST), modLoc("akashic/read"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqwqqqqqaq", HexDir.WEST), modLoc("akashic/read"), OpAkashicRead.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eeeweeeeede", HexDir.EAST), modLoc("akashic/write"), + PatternRegistry.mapPattern(HexPattern.fromAngles("eeeweeeeede", HexDir.EAST), modLoc("akashic/write"), OpAkashicWrite.INSTANCE); // == Meta stuff == - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqq", HexDir.WEST), modLoc("open_paren"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqq", HexDir.WEST), modLoc("open_paren"), Widget.OPEN_PAREN); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eee", HexDir.EAST), modLoc("close_paren"), + PatternRegistry.mapPattern(HexPattern.fromAngles("eee", HexDir.EAST), modLoc("close_paren"), Widget.CLOSE_PAREN); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqaw", HexDir.WEST), modLoc("escape"), Widget.ESCAPE); + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqaw", HexDir.WEST), modLoc("escape"), Widget.ESCAPE); // http://www.toroidalsnark.net/mkss3-pix/CalderheadJMM2014.pdf // eval being a space filling curve feels apt doesn't it - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("deaqq", HexDir.SOUTH_EAST), modLoc("eval"), + PatternRegistry.mapPattern(HexPattern.fromAngles("deaqq", HexDir.SOUTH_EAST), modLoc("eval"), OpEval.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aqdee", HexDir.SOUTH_WEST), modLoc("halt"), + PatternRegistry.mapPattern(HexPattern.fromAngles("aqdee", HexDir.SOUTH_WEST), modLoc("halt"), OpHalt.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aqqqqq", HexDir.EAST), modLoc("read"), + PatternRegistry.mapPattern(HexPattern.fromAngles("aqqqqq", HexDir.EAST), modLoc("read"), OpRead.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("deeeee", HexDir.EAST), modLoc("write"), + PatternRegistry.mapPattern(HexPattern.fromAngles("deeeee", HexDir.EAST), modLoc("write"), OpWrite.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aqqqqqe", HexDir.EAST), modLoc("readable"), + PatternRegistry.mapPattern(HexPattern.fromAngles("aqqqqqe", HexDir.EAST), modLoc("readable"), OpReadable.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("deeeeeq", HexDir.EAST), modLoc("writable"), + PatternRegistry.mapPattern(HexPattern.fromAngles("deeeeeq", HexDir.EAST), modLoc("writable"), OpWritable.INSTANCE); // lorge boyes - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wawqwqwqwqwqw", HexDir.EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("wawqwqwqwqwqw", HexDir.EAST), modLoc("read/entity"), OpTheCoolerRead.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wawqwqwqwqwqwew", HexDir.EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("wawqwqwqwqwqwew", HexDir.EAST), modLoc("readable/entity"), OpTheCoolerReadable.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qeewdweddw", HexDir.NORTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qeewdweddw", HexDir.NORTH_EAST), modLoc("read/local"), OpPeekLocal.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eqqwawqaaw", HexDir.NORTH_WEST), + PatternRegistry.mapPattern(HexPattern.fromAngles("eqqwawqaaw", HexDir.NORTH_WEST), modLoc("write/local"), OpPushLocal.INSTANCE); // == Consts == - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("d", HexDir.EAST), modLoc("const/null"), Widget.NULL); + PatternRegistry.mapPattern(HexPattern.fromAngles("d", HexDir.EAST), modLoc("const/null"), Widget.NULL); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqea", HexDir.NORTH_WEST), modLoc("const/vec/px"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqea", HexDir.NORTH_WEST), modLoc("const/vec/px"), Operator.makeConstantOp(SpellDatum.make(new Vec3(1.0, 0.0, 0.0)))); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqew", HexDir.NORTH_WEST), modLoc("const/vec/py"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqew", HexDir.NORTH_WEST), modLoc("const/vec/py"), Operator.makeConstantOp(SpellDatum.make(new Vec3(0.0, 1.0, 0.0)))); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqed", HexDir.NORTH_WEST), modLoc("const/vec/pz"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqed", HexDir.NORTH_WEST), modLoc("const/vec/pz"), Operator.makeConstantOp(SpellDatum.make(new Vec3(0.0, 0.0, 1.0)))); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eeeeeqa", HexDir.SOUTH_WEST), modLoc("const/vec/nx"), + PatternRegistry.mapPattern(HexPattern.fromAngles("eeeeeqa", HexDir.SOUTH_WEST), modLoc("const/vec/nx"), Operator.makeConstantOp(SpellDatum.make(new Vec3(-1.0, 0.0, 0.0)))); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eeeeeqw", HexDir.SOUTH_WEST), modLoc("const/vec/ny"), + PatternRegistry.mapPattern(HexPattern.fromAngles("eeeeeqw", HexDir.SOUTH_WEST), modLoc("const/vec/ny"), Operator.makeConstantOp(SpellDatum.make(new Vec3(0.0, -1.0, 0.0)))); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eeeeeqd", HexDir.SOUTH_WEST), modLoc("const/vec/nz"), + PatternRegistry.mapPattern(HexPattern.fromAngles("eeeeeqd", HexDir.SOUTH_WEST), modLoc("const/vec/nz"), Operator.makeConstantOp(SpellDatum.make(new Vec3(0.0, 0.0, -1.0)))); // Yep, this is what I spend the "plain hexagon" pattern on. - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqq", HexDir.NORTH_WEST), modLoc("const/vec/0"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqq", HexDir.NORTH_WEST), modLoc("const/vec/0"), Operator.makeConstantOp(SpellDatum.make(new Vec3(0.0, 0.0, 0.0)))); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qdwdq", HexDir.NORTH_EAST), modLoc("const/double/pi"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qdwdq", HexDir.NORTH_EAST), modLoc("const/double/pi"), Operator.makeConstantOp(SpellDatum.make(Math.PI))); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eawae", HexDir.NORTH_WEST), modLoc("const/double/tau"), + PatternRegistry.mapPattern(HexPattern.fromAngles("eawae", HexDir.NORTH_WEST), modLoc("const/double/tau"), Operator.makeConstantOp(SpellDatum.make(HexUtils.TAU))); // e - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aaq", HexDir.EAST), modLoc("const/double/e"), + PatternRegistry.mapPattern(HexPattern.fromAngles("aaq", HexDir.EAST), modLoc("const/double/e"), Operator.makeConstantOp(SpellDatum.make(Math.E))); // == Entities == - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqdaqa", HexDir.SOUTH_EAST), modLoc("get_entity"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqdaqa", HexDir.SOUTH_EAST), modLoc("get_entity"), new OpGetEntityAt(e -> true)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqdaqaawa", HexDir.SOUTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqdaqaawa", HexDir.SOUTH_EAST), modLoc("get_entity/animal"), new OpGetEntityAt(OpGetEntitiesBy::isAnimal)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqdaqaawq", HexDir.SOUTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqdaqaawq", HexDir.SOUTH_EAST), modLoc("get_entity/monster"), new OpGetEntityAt(OpGetEntitiesBy::isMonster)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqdaqaaww", HexDir.SOUTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqdaqaaww", HexDir.SOUTH_EAST), modLoc("get_entity/item"), new OpGetEntityAt(OpGetEntitiesBy::isItem)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqdaqaawe", HexDir.SOUTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqdaqaawe", HexDir.SOUTH_EAST), modLoc("get_entity/player"), new OpGetEntityAt(OpGetEntitiesBy::isPlayer)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqdaqaawd", HexDir.SOUTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqdaqaawd", HexDir.SOUTH_EAST), modLoc("get_entity/living"), new OpGetEntityAt(OpGetEntitiesBy::isLiving)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqwded", HexDir.SOUTH_EAST), modLoc("zone_entity"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqwded", HexDir.SOUTH_EAST), modLoc("zone_entity"), new OpGetEntitiesBy(e -> true, false)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqwdeddwa", HexDir.SOUTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqwdeddwa", HexDir.SOUTH_EAST), modLoc("zone_entity/animal"), new OpGetEntitiesBy(OpGetEntitiesBy::isAnimal, false)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eeeeewaqaawa", HexDir.NORTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("eeeeewaqaawa", HexDir.NORTH_EAST), modLoc("zone_entity/not_animal"), new OpGetEntitiesBy(OpGetEntitiesBy::isAnimal, true)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqwdeddwq", HexDir.SOUTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqwdeddwq", HexDir.SOUTH_EAST), modLoc("zone_entity/monster"), new OpGetEntitiesBy(OpGetEntitiesBy::isMonster, false)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eeeeewaqaawq", HexDir.NORTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("eeeeewaqaawq", HexDir.NORTH_EAST), modLoc("zone_entity/not_monster"), new OpGetEntitiesBy(OpGetEntitiesBy::isMonster, true)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqwdeddww", HexDir.SOUTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqwdeddww", HexDir.SOUTH_EAST), modLoc("zone_entity/item"), new OpGetEntitiesBy(OpGetEntitiesBy::isItem, false)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eeeeewaqaaww", HexDir.NORTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("eeeeewaqaaww", HexDir.NORTH_EAST), modLoc("zone_entity/not_item"), new OpGetEntitiesBy(OpGetEntitiesBy::isItem, true)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqwdeddwe", HexDir.SOUTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqwdeddwe", HexDir.SOUTH_EAST), modLoc("zone_entity/player"), new OpGetEntitiesBy(OpGetEntitiesBy::isPlayer, false)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eeeeewaqaawe", HexDir.NORTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("eeeeewaqaawe", HexDir.NORTH_EAST), modLoc("zone_entity/not_player"), new OpGetEntitiesBy(OpGetEntitiesBy::isPlayer, true)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqwdeddwd", HexDir.SOUTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqqqwdeddwd", HexDir.SOUTH_EAST), modLoc("zone_entity/living"), new OpGetEntitiesBy(OpGetEntitiesBy::isLiving, false)); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eeeeewaqaawd", HexDir.NORTH_EAST), + PatternRegistry.mapPattern(HexPattern.fromAngles("eeeeewaqaawd", HexDir.NORTH_EAST), modLoc("zone_entity/not_living"), new OpGetEntitiesBy(OpGetEntitiesBy::isLiving, true)); // == Lists == - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("edqde", HexDir.SOUTH_WEST), modLoc("append"), + PatternRegistry.mapPattern(HexPattern.fromAngles("edqde", HexDir.SOUTH_WEST), modLoc("append"), OpAppend.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qaeaq", HexDir.NORTH_WEST), modLoc("concat"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qaeaq", HexDir.NORTH_WEST), modLoc("concat"), OpConcat.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("deeed", HexDir.NORTH_WEST), modLoc("index"), + PatternRegistry.mapPattern(HexPattern.fromAngles("deeed", HexDir.NORTH_WEST), modLoc("index"), OpIndex.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("dadad", HexDir.NORTH_EAST), modLoc("for_each"), + PatternRegistry.mapPattern(HexPattern.fromAngles("dadad", HexDir.NORTH_EAST), modLoc("for_each"), OpForEach.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aqaeaq", HexDir.EAST), modLoc("list_size"), + PatternRegistry.mapPattern(HexPattern.fromAngles("aqaeaq", HexDir.EAST), modLoc("list_size"), OpListSize.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("adeeed", HexDir.EAST), modLoc("singleton"), + PatternRegistry.mapPattern(HexPattern.fromAngles("adeeed", HexDir.EAST), modLoc("singleton"), OpSingleton.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqaeaae", HexDir.NORTH_EAST), modLoc("empty_list"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqaeaae", HexDir.NORTH_EAST), modLoc("empty_list"), OpEmptyList.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqaede", HexDir.EAST), modLoc("reverse_list"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qqqaede", HexDir.EAST), modLoc("reverse_list"), OpReverski.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("ewdqdwe", HexDir.SOUTH_WEST), modLoc("last_n_list"), + PatternRegistry.mapPattern(HexPattern.fromAngles("ewdqdwe", HexDir.SOUTH_WEST), modLoc("last_n_list"), OpLastNToList.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qwaeawq", HexDir.NORTH_WEST), modLoc("splat"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qwaeawq", HexDir.NORTH_WEST), modLoc("splat"), OpSplat.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("dedqde", HexDir.EAST), modLoc("index_of"), + PatternRegistry.mapPattern(HexPattern.fromAngles("dedqde", HexDir.EAST), modLoc("index_of"), OpIndexOf.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("edqdewaqa", HexDir.SOUTH_WEST), modLoc("list_remove"), + PatternRegistry.mapPattern(HexPattern.fromAngles("edqdewaqa", HexDir.SOUTH_WEST), modLoc("list_remove"), OpRemove.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qaeaqwded", HexDir.NORTH_WEST), modLoc("slice"), + PatternRegistry.mapPattern(HexPattern.fromAngles("qaeaqwded", HexDir.NORTH_WEST), modLoc("slice"), OpSlice.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wqaeaqw", HexDir.NORTH_WEST), modLoc("modify_in_place"), + PatternRegistry.mapPattern(HexPattern.fromAngles("wqaeaqw", HexDir.NORTH_WEST), modLoc("modify_in_place"), OpModifyInPlace.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("ddewedd", HexDir.SOUTH_EAST), modLoc("construct"), + PatternRegistry.mapPattern(HexPattern.fromAngles("ddewedd", HexDir.SOUTH_EAST), modLoc("construct"), OpCons.INSTANCE); - PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aaqwqaa", HexDir.SOUTH_WEST), modLoc("deconstruct"), + PatternRegistry.mapPattern(HexPattern.fromAngles("aaqwqaa", HexDir.SOUTH_WEST), modLoc("deconstruct"), OpUnCons.INSTANCE); } catch (PatternRegistry.RegisterPatternException exn) { diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/eval/OpEval.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/eval/OpEval.kt index 95d44944..c63af6a5 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/eval/OpEval.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/eval/OpEval.kt @@ -1,14 +1,8 @@ package at.petrak.hexcasting.common.casting.operators.eval -import at.petrak.hexcasting.api.spell.OperationResult -import at.petrak.hexcasting.api.spell.Operator -import at.petrak.hexcasting.api.spell.getChecked -import at.petrak.hexcasting.api.spell.SpellDatum -import at.petrak.hexcasting.api.spell.SpellList +import at.petrak.hexcasting.api.spell.* import at.petrak.hexcasting.api.spell.casting.CastingContext -import at.petrak.hexcasting.api.spell.casting.CastingHarness import at.petrak.hexcasting.api.spell.casting.ContinuationFrame -import at.petrak.hexcasting.api.spell.casting.OperatorSideEffect import at.petrak.hexcasting.api.spell.casting.SpellContinuation object OpEval : Operator { @@ -22,7 +16,7 @@ object OpEval : Operator { val newCont = if (continuation is SpellContinuation.NotDone && continuation.frame is ContinuationFrame.FinishEval) { continuation } else { - continuation.pushFrame(ContinuationFrame.FinishEval()) // install a break-boundary after eval + continuation.pushFrame(ContinuationFrame.FinishEval) // install a break-boundary after eval } val frame = ContinuationFrame.Evaluate(instrs) diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpAbsLen.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpAbsLen.kt index 8c39fecd..4689d523 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpAbsLen.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpAbsLen.kt @@ -1,7 +1,7 @@ package at.petrak.hexcasting.common.casting.operators.math import at.petrak.hexcasting.api.spell.ConstManaOperator -import at.petrak.hexcasting.api.spell.GetNumOrVec +import at.petrak.hexcasting.api.spell.numOrVec import at.petrak.hexcasting.api.spell.SpellDatum import at.petrak.hexcasting.api.spell.asSpellResult import at.petrak.hexcasting.api.spell.casting.CastingContext @@ -12,7 +12,7 @@ object OpAbsLen : ConstManaOperator { get() = 1 override fun execute(args: List>, ctx: CastingContext): List> { - val x = GetNumOrVec(args[0], 0) + val x = numOrVec(args[0], 0) return x.map({ num -> num.absoluteValue }, { vec -> vec.length() }).asSpellResult } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpAdd.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpAdd.kt index 57d8d458..5e198419 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpAdd.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpAdd.kt @@ -1,7 +1,7 @@ package at.petrak.hexcasting.common.casting.operators.math import at.petrak.hexcasting.api.spell.ConstManaOperator -import at.petrak.hexcasting.api.spell.GetNumOrVec +import at.petrak.hexcasting.api.spell.numOrVec import at.petrak.hexcasting.api.spell.SpellDatum import at.petrak.hexcasting.api.spell.casting.CastingContext import at.petrak.hexcasting.api.spell.spellListOf @@ -11,8 +11,8 @@ object OpAdd : ConstManaOperator { get() = 2 override fun execute(args: List>, ctx: CastingContext): List> { - val lhs = GetNumOrVec(args[0], 1) - val rhs = GetNumOrVec(args[1], 0) + val lhs = numOrVec(args[0], 1) + val rhs = numOrVec(args[1], 0) return spellListOf( lhs.map({ lnum -> diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpDivCross.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpDivCross.kt index 2272c0e0..3d9a8339 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpDivCross.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpDivCross.kt @@ -1,7 +1,7 @@ package at.petrak.hexcasting.common.casting.operators.math import at.petrak.hexcasting.api.spell.ConstManaOperator -import at.petrak.hexcasting.api.spell.GetNumOrVec +import at.petrak.hexcasting.api.spell.numOrVec import at.petrak.hexcasting.api.spell.SpellDatum import at.petrak.hexcasting.api.spell.casting.CastingContext import at.petrak.hexcasting.api.spell.mishaps.MishapDivideByZero @@ -13,8 +13,8 @@ object OpDivCross : ConstManaOperator { get() = 2 override fun execute(args: List>, ctx: CastingContext): List> { - val lhs = GetNumOrVec(args[0], 1) - val rhs = GetNumOrVec(args[1], 0) + val lhs = numOrVec(args[0], 1) + val rhs = numOrVec(args[1], 0) return spellListOf( lhs.map({ lnum -> diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpMulDot.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpMulDot.kt index 2dfb5b19..51190788 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpMulDot.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpMulDot.kt @@ -1,7 +1,7 @@ package at.petrak.hexcasting.common.casting.operators.math import at.petrak.hexcasting.api.spell.ConstManaOperator -import at.petrak.hexcasting.api.spell.GetNumOrVec +import at.petrak.hexcasting.api.spell.numOrVec import at.petrak.hexcasting.api.spell.spellListOf import at.petrak.hexcasting.api.spell.SpellDatum import at.petrak.hexcasting.api.spell.casting.CastingContext @@ -11,8 +11,8 @@ object OpMulDot : ConstManaOperator { get() = 2 override fun execute(args: List>, ctx: CastingContext): List> { - val lhs = GetNumOrVec(args[0], 1) - val rhs = GetNumOrVec(args[1], 0) + val lhs = numOrVec(args[0], 1) + val rhs = numOrVec(args[1], 0) return spellListOf( lhs.map({ lnum -> diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpPowProj.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpPowProj.kt index 687721b4..3dce748e 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpPowProj.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpPowProj.kt @@ -1,7 +1,7 @@ package at.petrak.hexcasting.common.casting.operators.math import at.petrak.hexcasting.api.spell.ConstManaOperator -import at.petrak.hexcasting.api.spell.GetNumOrVec +import at.petrak.hexcasting.api.spell.numOrVec import at.petrak.hexcasting.api.spell.SpellDatum import at.petrak.hexcasting.api.spell.casting.CastingContext import at.petrak.hexcasting.api.spell.mishaps.MishapDivideByZero @@ -14,8 +14,8 @@ object OpPowProj : ConstManaOperator { get() = 2 override fun execute(args: List>, ctx: CastingContext): List> { - val lhs = GetNumOrVec(args[0], 1) - val rhs = GetNumOrVec(args[1], 0) + val lhs = numOrVec(args[0], 1) + val rhs = numOrVec(args[1], 0) return spellListOf( lhs.map({ lnum -> diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpSub.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpSub.kt index 84bec878..01bd708a 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpSub.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpSub.kt @@ -1,7 +1,7 @@ package at.petrak.hexcasting.common.casting.operators.math import at.petrak.hexcasting.api.spell.ConstManaOperator -import at.petrak.hexcasting.api.spell.GetNumOrVec +import at.petrak.hexcasting.api.spell.numOrVec import at.petrak.hexcasting.api.spell.SpellDatum import at.petrak.hexcasting.api.spell.casting.CastingContext import at.petrak.hexcasting.api.spell.spellListOf @@ -12,8 +12,8 @@ object OpSub : ConstManaOperator { get() = 2 override fun execute(args: List>, ctx: CastingContext): List> { - val lhs = GetNumOrVec(args[0], 1) - val rhs = GetNumOrVec(args[1], 0) + val lhs = numOrVec(args[0], 1) + val rhs = numOrVec(args[1], 0) return spellListOf( lhs.map({ lnum -> diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpAnd.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpAnd.kt index ee8d3a4c..28eca0e4 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpAnd.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpAnd.kt @@ -8,7 +8,7 @@ object OpAnd : ConstManaOperator { override val argc = 2 override fun execute(args: List>, ctx: CastingContext): List> { - val firstParam = GetNumOrList(args[0], 0) + val firstParam = numOrList(args[0], 0) if (firstParam.right().isPresent) { val list1 = firstParam.right().get() diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpOr.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpOr.kt index 93a79dc9..8183b65f 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpOr.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpOr.kt @@ -8,7 +8,7 @@ object OpOr : ConstManaOperator { override val argc = 2 override fun execute(args: List>, ctx: CastingContext): List> { - val firstParam = GetNumOrList(args[0], 0) + val firstParam = numOrList(args[0], 0) if (firstParam.right().isPresent) { val list1 = firstParam.right().get() diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpXor.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpXor.kt index a65c0a79..1bca8ecb 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpXor.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpXor.kt @@ -8,7 +8,7 @@ object OpXor : ConstManaOperator { override val argc = 2 override fun execute(args: List>, ctx: CastingContext): List> { - val firstParam = GetNumOrList(args[0], 0) + val firstParam = numOrList(args[0], 0) if (firstParam.right().isPresent) { val list1 = firstParam.right().get() diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBeep.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBeep.kt index becef5d4..8b762177 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBeep.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBeep.kt @@ -27,7 +27,7 @@ object OpBeep : SpellOperator { return Triple( Spell(target, note, NoteBlockInstrument.values()[instrument]), ManaConstants.DUST_UNIT / 10, - listOf(ParticleSpray.Cloud(target, 1.0)) + listOf(ParticleSpray.cloud(target, 1.0)) ) } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBlink.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBlink.kt index bbfdd0db..fb59c18e 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBlink.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBlink.kt @@ -39,8 +39,8 @@ object OpBlink : SpellOperator { Spell(target, delta), ManaConstants.SHARD_UNIT * delta.roundToInt(), listOf( - ParticleSpray.Cloud(targetMiddlePos, 2.0, 50), - ParticleSpray.Burst(targetMiddlePos.add(dvec), 2.0, 100) + ParticleSpray.cloud(targetMiddlePos, 2.0, 50), + ParticleSpray.burst(targetMiddlePos.add(dvec), 2.0, 100) ) ) } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBreakBlock.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBreakBlock.kt index 7f4fc37d..e89ea4d9 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBreakBlock.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBreakBlock.kt @@ -27,7 +27,7 @@ object OpBreakBlock : SpellOperator { return Triple( Spell(pos), ManaConstants.DUST_UNIT * 2, - listOf(ParticleSpray.Burst(centered, 1.0)) + listOf(ParticleSpray.burst(centered, 1.0)) ) } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpConjure.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpConjure.kt index a1b43adb..6eca6d16 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpConjure.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpConjure.kt @@ -36,7 +36,7 @@ class OpConjure(val light: Boolean) : SpellOperator { return Triple( Spell(target, light), ManaConstants.DUST_UNIT, - listOf(ParticleSpray.Cloud(Vec3.atCenterOf(pos), 1.0)) + listOf(ParticleSpray.cloud(Vec3.atCenterOf(pos), 1.0)) ) } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpCreateWater.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpCreateWater.kt index 12381ef0..95b80cbd 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpCreateWater.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpCreateWater.kt @@ -31,7 +31,7 @@ object OpCreateWater : SpellOperator { return Triple( Spell(target), ManaConstants.DUST_UNIT, - listOf(ParticleSpray.Burst(Vec3.atCenterOf(BlockPos(target)), 1.0)) + listOf(ParticleSpray.burst(Vec3.atCenterOf(BlockPos(target)), 1.0)) ) } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpDestroyWater.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpDestroyWater.kt index 8c68663c..7337faff 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpDestroyWater.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpDestroyWater.kt @@ -29,7 +29,7 @@ object OpDestroyWater : SpellOperator { return Triple( Spell(target), 2 * ManaConstants.CRYSTAL_UNIT, - listOf(ParticleSpray.Burst(target, 3.0)) + listOf(ParticleSpray.burst(target, 3.0)) ) } 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 6098af88..f7a987a2 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 @@ -22,7 +22,7 @@ class OpExplode(val fire: Boolean) : SpellOperator { return Triple( Spell(pos, strength, this.fire), ((1 + Mth.clamp(strength.toFloat(), 0f, 10f) + if (this.fire) 2 else 0) * ManaConstants.SHARD_UNIT).toInt(), - listOf(ParticleSpray.Burst(pos, strength, 50)) + listOf(ParticleSpray.burst(pos, strength, 50)) ) } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpExtinguish.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpExtinguish.kt index c6851287..4782adff 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpExtinguish.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpExtinguish.kt @@ -28,7 +28,7 @@ object OpExtinguish : SpellOperator { return Triple( Spell(target), ManaConstants.CRYSTAL_UNIT, - listOf(ParticleSpray.Burst(target, 1.0)) + listOf(ParticleSpray.burst(target, 1.0)) ) } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpIgnite.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpIgnite.kt index 2d6f7084..f91da46d 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpIgnite.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpIgnite.kt @@ -31,7 +31,7 @@ object OpIgnite : SpellOperator { return Triple( Spell(target), ManaConstants.DUST_UNIT, - listOf(ParticleSpray.Burst(Vec3.atCenterOf(BlockPos(target)), 1.0)) + listOf(ParticleSpray.burst(Vec3.atCenterOf(BlockPos(target)), 1.0)) ) } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpMakeBattery.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpMakeBattery.kt index c4a655b0..0b7865eb 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpMakeBattery.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpMakeBattery.kt @@ -59,7 +59,7 @@ object OpMakeBattery : SpellOperator { } return Triple(Spell(entity), - ManaConstants.CRYSTAL_UNIT, listOf(ParticleSpray.Burst(entity.position(), 0.5))) + ManaConstants.CRYSTAL_UNIT, listOf(ParticleSpray.burst(entity.position(), 0.5))) } private data class Spell(val itemEntity: ItemEntity) : RenderedSpell { diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpMakePackagedSpell.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpMakePackagedSpell.kt index be54d2f2..faf61588 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpMakePackagedSpell.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpMakePackagedSpell.kt @@ -52,7 +52,7 @@ class OpMakePackagedSpell(val itemType: T, val cost: Int) : if (trueName != null) throw MishapOthersName(trueName) - return Triple(Spell(entity, patterns), cost, listOf(ParticleSpray.Burst(entity.position(), 0.5))) + return Triple(Spell(entity, patterns), cost, listOf(ParticleSpray.burst(entity.position(), 0.5))) } private inner class Spell(val itemEntity: ItemEntity, val patterns: List>) : RenderedSpell { 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 b1ea327e..bfc30b9a 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 @@ -45,7 +45,7 @@ object OpPlaceBlock : SpellOperator { return Triple( Spell(target), ManaConstants.DUST_UNIT, - listOf(ParticleSpray.Cloud(Vec3.atCenterOf(pos), 1.0)) + listOf(ParticleSpray.cloud(Vec3.atCenterOf(pos), 1.0)) ) } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPotionEffect.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPotionEffect.kt index cd4e14cf..5306bdde 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPotionEffect.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPotionEffect.kt @@ -44,7 +44,7 @@ class OpPotionEffect( return Triple( Spell(effect, target, duration, potency), cost.toInt(), - listOf(ParticleSpray.Cloud(target.position().add(0.0, target.eyeHeight / 2.0, 0.0), 1.0)) + listOf(ParticleSpray.cloud(target.position().add(0.0, target.eyeHeight / 2.0, 0.0), 1.0)) ) } 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 1c84c7c1..9798bca0 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 @@ -48,7 +48,7 @@ object OpRecharge : SpellOperator { return null return Triple(Spell(entity), - ManaConstants.CRYSTAL_UNIT, listOf(ParticleSpray.Burst(entity.position(), 0.5))) + ManaConstants.CRYSTAL_UNIT, listOf(ParticleSpray.burst(entity.position(), 0.5))) } private data class Spell(val itemEntity: ItemEntity) : RenderedSpell { diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpTheOnlyReasonAnyoneDownloadedPsi.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpTheOnlyReasonAnyoneDownloadedPsi.kt index 489ca92d..bb7ac432 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpTheOnlyReasonAnyoneDownloadedPsi.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpTheOnlyReasonAnyoneDownloadedPsi.kt @@ -29,7 +29,7 @@ object OpTheOnlyReasonAnyoneDownloadedPsi : SpellOperator { return Triple( Spell(target), ManaConstants.DUST_UNIT, - listOf(ParticleSpray.Burst(Vec3.atCenterOf(BlockPos(target)), 1.0)) + listOf(ParticleSpray.burst(Vec3.atCenterOf(BlockPos(target)), 1.0)) ) } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpBrainsweep.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpBrainsweep.kt index 2fdb6b17..e1ea9608 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpBrainsweep.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpBrainsweep.kt @@ -47,7 +47,7 @@ object OpBrainsweep : SpellOperator { return Triple( Spell(bpos, state, sacrifice, recipe), 10 * ManaConstants.CRYSTAL_UNIT, - listOf(ParticleSpray.Cloud(sacrifice.position(), 1.0), ParticleSpray.Burst(Vec3.atCenterOf(bpos), 0.3, 100)) + listOf(ParticleSpray.cloud(sacrifice.position(), 1.0), ParticleSpray.burst(Vec3.atCenterOf(bpos), 0.3, 100)) ) } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpCreateLava.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpCreateLava.kt index 89a4086d..f0c8f0c6 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpCreateLava.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpCreateLava.kt @@ -31,7 +31,7 @@ object OpCreateLava : SpellOperator { return Triple( Spell(target), ManaConstants.CRYSTAL_UNIT, - listOf(ParticleSpray.Burst(Vec3.atCenterOf(BlockPos(target)), 1.0)), + listOf(ParticleSpray.burst(Vec3.atCenterOf(BlockPos(target)), 1.0)), ) } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpTeleport.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpTeleport.kt index 6fd37378..fa7e4ba6 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpTeleport.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpTeleport.kt @@ -36,7 +36,7 @@ object OpTeleport : SpellOperator { return Triple( Spell(teleportee, delta), 10 * ManaConstants.CRYSTAL_UNIT, - listOf(ParticleSpray.Cloud(targetMiddlePos, 2.0), ParticleSpray.Burst(targetMiddlePos.add(delta), 2.0)) + listOf(ParticleSpray.cloud(targetMiddlePos, 2.0), ParticleSpray.burst(targetMiddlePos.add(delta), 2.0)) ) } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpCreateSentinel.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpCreateSentinel.kt index 8029ad81..0711f252 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpCreateSentinel.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpCreateSentinel.kt @@ -26,7 +26,7 @@ class OpCreateSentinel(val extendsRange: Boolean) : SpellOperator { return Triple( Spell(target, this.extendsRange), ManaConstants.DUST_UNIT, - listOf(ParticleSpray.Burst(target, 2.0)) + listOf(ParticleSpray.burst(target, 2.0)) ) } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpDestroySentinel.kt b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpDestroySentinel.kt index d0afd3d0..9a339535 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpDestroySentinel.kt +++ b/Common/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpDestroySentinel.kt @@ -22,7 +22,7 @@ object OpDestroySentinel : SpellOperator { // TODO why can't you remove things from other dimensions? if (sentinel.dimension != ctx.world.dimension()) throw MishapLocationInWrongDimension(sentinel.dimension.location()) - particles.add(ParticleSpray.Cloud(sentinel.position, 2.0)) + particles.add(ParticleSpray.cloud(sentinel.position, 2.0)) return Triple( Spell, diff --git a/Common/src/main/java/at/petrak/hexcasting/common/command/ListPatternsCommand.java b/Common/src/main/java/at/petrak/hexcasting/common/command/ListPatternsCommand.java index 2a068dfd..b1c66609 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/command/ListPatternsCommand.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/command/ListPatternsCommand.java @@ -32,7 +32,7 @@ public class ListPatternsCommand { for (var pair : listing) { ctx.getSource().sendSuccess(new TextComponent(pair.getValue().getFirst().toString()) .append(": ") - .append(SpellDatum.make(HexPattern.FromAnglesSig(pair.getKey(), pair.getValue().getSecond())) + .append(SpellDatum.make(HexPattern.fromAngles(pair.getKey(), pair.getValue().getSecond())) .display()), false); } @@ -86,7 +86,7 @@ public class ListPatternsCommand { var tag = new CompoundTag(); tag.putString(ItemScroll.TAG_OP_ID, opId.toString()); tag.put(ItemScroll.TAG_PATTERN, - HexPattern.FromAnglesSig(pattern, startDir).serializeToNBT()); + HexPattern.fromAngles(pattern, startDir).serializeToNBT()); var stack = new ItemStack(HexItems.SCROLL); stack.setTag(tag); diff --git a/Common/src/main/java/at/petrak/hexcasting/common/command/PatternResLocArgument.java b/Common/src/main/java/at/petrak/hexcasting/common/command/PatternResLocArgument.java index 536fe2c4..ba082c5b 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/command/PatternResLocArgument.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/command/PatternResLocArgument.java @@ -38,7 +38,7 @@ public class PatternResLocArgument extends ResourceLocationArgument { for (var key : lookup.keySet()) { var rhs = lookup.get(key); if (rhs.getFirst().equals(targetId)) { - foundPat = HexPattern.FromAnglesSig(key, rhs.getSecond()); + foundPat = HexPattern.fromAngles(key, rhs.getSecond()); break; } } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/entities/EntityWallScroll.java b/Common/src/main/java/at/petrak/hexcasting/common/entities/EntityWallScroll.java index 51d4653c..856c7ac8 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/entities/EntityWallScroll.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/entities/EntityWallScroll.java @@ -1,6 +1,5 @@ package at.petrak.hexcasting.common.entities; -import at.petrak.hexcasting.annotations.SoftImplement; import at.petrak.hexcasting.api.spell.math.HexPattern; import at.petrak.hexcasting.api.utils.HexUtils; import at.petrak.hexcasting.api.utils.NBTHelper; @@ -27,7 +26,6 @@ import net.minecraft.world.entity.player.Player; import net.minecraft.world.item.ItemStack; import net.minecraft.world.level.GameRules; import net.minecraft.world.level.Level; -import net.minecraft.world.phys.HitResult; import net.minecraft.world.phys.Vec2; import net.minecraft.world.phys.Vec3; import org.jetbrains.annotations.Nullable; @@ -60,7 +58,7 @@ public class EntityWallScroll extends HangingEntity { CompoundTag patternTag = NBTHelper.getCompound(scroll, ItemScroll.TAG_PATTERN); if (patternTag != null) { - this.pattern = HexPattern.DeserializeFromNBT(patternTag); + this.pattern = HexPattern.fromNBT(patternTag); if (this.level.isClientSide) { var pair = RenderLib.getCenteredPattern(pattern, 128, 128, 16f); var dots = pair.getSecond(); @@ -160,7 +158,7 @@ public class EntityWallScroll extends HangingEntity { @Override public void addAdditionalSaveData(CompoundTag tag) { tag.putByte("direction", (byte) this.direction.ordinal()); - tag.put("scroll", HexUtils.serialize(this.scroll)); + tag.put("scroll", HexUtils.serializeToNBT(this.scroll)); tag.putBoolean("showsStrokeOrder", this.getShowsStrokeOrder()); super.addAdditionalSaveData(tag); } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/items/ItemScroll.java b/Common/src/main/java/at/petrak/hexcasting/common/items/ItemScroll.java index 4f605a14..89b36cda 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/items/ItemScroll.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/items/ItemScroll.java @@ -125,7 +125,7 @@ public class ItemScroll extends Item implements DataHolderItem { public Optional getTooltipImage(ItemStack stack) { var compound = NBTHelper.getCompound(stack, ItemScroll.TAG_PATTERN); if (compound != null) { - var pattern = HexPattern.DeserializeFromNBT(compound); + var pattern = HexPattern.fromNBT(compound); return Optional.of(new PatternTooltipGreeble( pattern, NBTHelper.hasString(stack, ItemScroll.TAG_OP_ID) ? PatternTooltipGreeble.ANCIENT_BG : PatternTooltipGreeble.PRISTINE_BG)); diff --git a/Common/src/main/java/at/petrak/hexcasting/common/items/ItemSlate.java b/Common/src/main/java/at/petrak/hexcasting/common/items/ItemSlate.java index 52768436..79fb7fbf 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/items/ItemSlate.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/items/ItemSlate.java @@ -106,7 +106,7 @@ public class ItemSlate extends BlockItem implements DataHolderItem { if (bet != null && bet.contains(BlockEntitySlate.TAG_PATTERN, Tag.TAG_COMPOUND)) { var patTag = bet.getCompound(BlockEntitySlate.TAG_PATTERN); if (!patTag.isEmpty()) { - var pattern = HexPattern.DeserializeFromNBT(patTag); + var pattern = HexPattern.fromNBT(patTag); return Optional.of(new PatternTooltipGreeble( pattern, PatternTooltipGreeble.SLATE_BG)); diff --git a/Common/src/main/java/at/petrak/hexcasting/common/items/magic/ItemPackagedHex.java b/Common/src/main/java/at/petrak/hexcasting/common/items/magic/ItemPackagedHex.java index b48a8778..afcdc825 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/items/magic/ItemPackagedHex.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/items/magic/ItemPackagedHex.java @@ -68,9 +68,9 @@ public abstract class ItemPackagedHex extends ItemManaHolder implements HexHolde for (var patTag : patsTag) { CompoundTag tag = NBTHelper.getAsCompound(patTag); if (tag.size() != 1) - out.add(SpellDatum.make(HexPattern.DeserializeFromNBT(tag))); + out.add(SpellDatum.make(HexPattern.fromNBT(tag))); else - out.add(SpellDatum.DeserializeFromNBT(tag, level)); + out.add(SpellDatum.fromNBT(tag, level)); } return out; } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/loot/PatternScrollFunc.java b/Common/src/main/java/at/petrak/hexcasting/common/loot/PatternScrollFunc.java index 930ce4c3..7c376629 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/loot/PatternScrollFunc.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/loot/PatternScrollFunc.java @@ -32,7 +32,7 @@ public class PatternScrollFunc extends LootItemConditionalFunction { var startDir = entry.component2(); var tag = new CompoundTag(); tag.putString(ItemScroll.TAG_OP_ID, opId.toString()); - tag.put(ItemScroll.TAG_PATTERN, HexPattern.FromAnglesSig(sig, startDir).serializeToNBT()); + tag.put(ItemScroll.TAG_PATTERN, HexPattern.fromAngles(sig, startDir).serializeToNBT()); stack.getOrCreateTag().merge(tag); diff --git a/Common/src/main/java/at/petrak/hexcasting/common/network/MsgCastParticleAck.java b/Common/src/main/java/at/petrak/hexcasting/common/network/MsgCastParticleAck.java index 174e1822..eb071c6d 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/network/MsgCastParticleAck.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/network/MsgCastParticleAck.java @@ -37,7 +37,7 @@ public record MsgCastParticleAck(ParticleSpray spray, FrozenColorizer colorizer) var spread = buf.readDouble(); var count = buf.readInt(); var tag = buf.readAnySizeNbt(); - var colorizer = FrozenColorizer.deserialize(tag); + var colorizer = FrozenColorizer.fromNBT(tag); return new MsgCastParticleAck( new ParticleSpray(new Vec3(posX, posY, posZ), new Vec3(velX, velY, velZ), fuzziness, spread, count), colorizer); @@ -54,7 +54,7 @@ public record MsgCastParticleAck(ParticleSpray spray, FrozenColorizer colorizer) buf.writeDouble(this.spray.getFuzziness()); buf.writeDouble(this.spray.getSpread()); buf.writeInt(this.spray.getCount()); - buf.writeNbt(this.colorizer.serialize()); + buf.writeNbt(this.colorizer.serializeToNBT()); } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/network/MsgNewSpellPatternSyn.java b/Common/src/main/java/at/petrak/hexcasting/common/network/MsgNewSpellPatternSyn.java index 8f01bc92..d7d49065 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/network/MsgNewSpellPatternSyn.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/network/MsgNewSpellPatternSyn.java @@ -39,12 +39,12 @@ public record MsgNewSpellPatternSyn(InteractionHand handUsed, HexPattern pattern public static MsgNewSpellPatternSyn deserialize(ByteBuf buffer) { var buf = new FriendlyByteBuf(buffer); var hand = buf.readEnum(InteractionHand.class); - var pattern = HexPattern.DeserializeFromNBT(buf.readAnySizeNbt()); + var pattern = HexPattern.fromNBT(buf.readAnySizeNbt()); var resolvedPatternsLen = buf.readInt(); var resolvedPatterns = new ArrayList(resolvedPatternsLen); for (int i = 0; i < resolvedPatternsLen; i++) { - resolvedPatterns.add(ResolvedPattern.DeserializeFromNBT(buf.readAnySizeNbt())); + resolvedPatterns.add(ResolvedPattern.fromNBT(buf.readAnySizeNbt())); } return new MsgNewSpellPatternSyn(hand, pattern, resolvedPatterns); } diff --git a/Common/src/main/java/at/petrak/hexcasting/common/network/MsgOpenSpellGuiAck.java b/Common/src/main/java/at/petrak/hexcasting/common/network/MsgOpenSpellGuiAck.java index 349f6c2b..ab9c9253 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/network/MsgOpenSpellGuiAck.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/network/MsgOpenSpellGuiAck.java @@ -34,7 +34,7 @@ public record MsgOpenSpellGuiAck(InteractionHand hand, List pat var patternsLen = buf.readInt(); var patterns = new ArrayList(patternsLen); for (int i = 0; i < patternsLen; i++) { - patterns.add(ResolvedPattern.DeserializeFromNBT(buf.readAnySizeNbt())); + patterns.add(ResolvedPattern.fromNBT(buf.readAnySizeNbt())); } var descsLen = buf.readInt(); diff --git a/Common/src/main/java/at/petrak/hexcasting/common/network/MsgShiftScrollSyn.java b/Common/src/main/java/at/petrak/hexcasting/common/network/MsgShiftScrollSyn.java index cf3a6502..64f014a4 100644 --- a/Common/src/main/java/at/petrak/hexcasting/common/network/MsgShiftScrollSyn.java +++ b/Common/src/main/java/at/petrak/hexcasting/common/network/MsgShiftScrollSyn.java @@ -121,7 +121,7 @@ public record MsgShiftScrollSyn(InteractionHand hand, double scrollDelta, boolea var datumTag = HexItems.ABACUS.readDatumTag(stack); if (datumTag != null) { - var popup = SpellDatum.DisplayFromTag(datumTag); + var popup = SpellDatum.displayFromNBT(datumTag); sender.displayClientMessage( new TranslatableComponent("hexcasting.tooltip.abacus", popup).withStyle(ChatFormatting.GREEN), true); } diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/ManualPatternComponent.java b/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/ManualPatternComponent.java index 12ce2765..52ea972a 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/ManualPatternComponent.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/patchouli/ManualPatternComponent.java @@ -35,7 +35,7 @@ public class ManualPatternComponent extends AbstractPatternComponent { RawPattern raw = new Gson().fromJson(json, RawPattern.class); var dir = HexDir.valueOf(raw.startdir); - var pat = HexPattern.FromAnglesSig(raw.signature, dir); + var pat = HexPattern.fromAngles(raw.signature, dir); var origin = new HexCoord(raw.q, raw.r); out.add(new Pair<>(pat, origin)); } diff --git a/Common/src/main/java/at/petrak/hexcasting/interop/utils/PatternDrawingUtil.java b/Common/src/main/java/at/petrak/hexcasting/interop/utils/PatternDrawingUtil.java index aca505cc..a94410ce 100644 --- a/Common/src/main/java/at/petrak/hexcasting/interop/utils/PatternDrawingUtil.java +++ b/Common/src/main/java/at/petrak/hexcasting/interop/utils/PatternDrawingUtil.java @@ -77,7 +77,7 @@ public final class PatternDrawingUtil { patternEntries.add(new PatternEntry(pattern, origin, new ArrayList<>())); seenCoords.addAll(pattern.positions(origin)); } - var fakeCom = HexUtils.FindCenter(seenFakePoints); + var fakeCom = HexUtils.findCenter(seenFakePoints); var maxDx = -1f; var maxDy = -1f; @@ -100,7 +100,7 @@ public final class PatternDrawingUtil { seenRealPoints.add(px); } } - var realCom = HexUtils.FindCenter(seenRealPoints); + var realCom = HexUtils.findCenter(seenRealPoints); // and NOW for real! for (var pat : patternEntries) { diff --git a/Common/src/test/java/EulerPathFinderTest.kt b/Common/src/test/java/EulerPathFinderTest.kt index e09c3ef8..2ff3f765 100644 --- a/Common/src/test/java/EulerPathFinderTest.kt +++ b/Common/src/test/java/EulerPathFinderTest.kt @@ -1,13 +1,13 @@ import at.petrak.hexcasting.api.spell.math.EulerPathFinder.findAltDrawing import at.petrak.hexcasting.api.spell.math.HexDir -import at.petrak.hexcasting.api.spell.math.HexPattern.Companion.FromAnglesSig +import at.petrak.hexcasting.api.spell.math.HexPattern.Companion.fromAngles import org.junit.jupiter.api.Test internal class EulerPathFinderTest { @Test fun findAltDrawing() { val sig = "dadaddwwaadada" - val pat = FromAnglesSig(sig, HexDir.NORTH_EAST) + val pat = fromAngles(sig, HexDir.NORTH_EAST) for (i in 0 until 8) { val scrungled = findAltDrawing(pat, i.toLong()) println(scrungled) diff --git a/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCFavoredColorizer.java b/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCFavoredColorizer.java index ae4a1be9..b60f10ff 100644 --- a/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCFavoredColorizer.java +++ b/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCFavoredColorizer.java @@ -31,11 +31,11 @@ public class CCFavoredColorizer implements Component, AutoSyncedComponent { @Override public void readFromNbt(CompoundTag tag) { - this.colorizer = FrozenColorizer.deserialize(tag.getCompound(TAG_COLORIZER)); + this.colorizer = FrozenColorizer.fromNBT(tag.getCompound(TAG_COLORIZER)); } @Override public void writeToNbt(CompoundTag tag) { - tag.put(TAG_COLORIZER, this.colorizer.serialize()); + tag.put(TAG_COLORIZER, this.colorizer.serializeToNBT()); } } diff --git a/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCFlight.java b/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCFlight.java index dccf2489..c0fcbea0 100644 --- a/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCFlight.java +++ b/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCFlight.java @@ -42,7 +42,7 @@ public class CCFlight implements Component { var timeLeft = tag.getInt(TAG_TIME_LEFT); var dim = ResourceKey.create(Registry.DIMENSION_REGISTRY, new ResourceLocation(tag.getString(TAG_DIMENSION))); - var origin = HexUtils.DeserializeVec3FromNBT(tag.getLongArray(TAG_ORIGIN)); + var origin = HexUtils.vecFromNBT(tag.getLongArray(TAG_ORIGIN)); var radius = tag.getDouble(TAG_RADIUS); this.flight = new FlightAbility(true, timeLeft, dim, origin, radius); } diff --git a/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCHarness.java b/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCHarness.java index d08bde73..c811bee0 100644 --- a/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCHarness.java +++ b/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCHarness.java @@ -17,13 +17,13 @@ public class CCHarness implements Component { public CCHarness(ServerPlayer owner) { this.owner = owner; } - + public CastingHarness getHarness(InteractionHand hand) { var ctx = new CastingContext(this.owner, hand); if (this.lazyLoadedTag.isEmpty()) { return new CastingHarness(ctx); } else { - return CastingHarness.DeserializeFromNBT(this.lazyLoadedTag, ctx); + return CastingHarness.fromNBT(this.lazyLoadedTag, ctx); } } diff --git a/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCPatterns.java b/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCPatterns.java index 868c8ea8..a42a650b 100644 --- a/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCPatterns.java +++ b/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCPatterns.java @@ -39,7 +39,7 @@ public class CCPatterns implements Component { List patterns = new ArrayList<>(patternsTag.size()); for (int i = 0; i < patternsTag.size(); i++) { - patterns.add(ResolvedPattern.DeserializeFromNBT(patternsTag.getCompound(i))); + patterns.add(ResolvedPattern.fromNBT(patternsTag.getCompound(i))); } this.patterns = patterns; } diff --git a/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCSentinel.java b/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCSentinel.java index b0cadef5..bd281092 100644 --- a/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCSentinel.java +++ b/Fabric/src/main/java/at/petrak/hexcasting/fabric/cc/CCSentinel.java @@ -38,7 +38,7 @@ public class CCSentinel implements Component, AutoSyncedComponent { var hasSentinel = tag.getBoolean(TAG_HAS_SENTINEL); if (hasSentinel) { var extendsRange = tag.getBoolean(TAG_EXTENDS_RANGE); - var position = HexUtils.DeserializeVec3FromNBT(tag.getLongArray(TAG_POSITION)); + var position = HexUtils.vecFromNBT(tag.getLongArray(TAG_POSITION)); var dim = ResourceKey.create(Registry.DIMENSION_REGISTRY, new ResourceLocation(tag.getString(TAG_DIMENSION))); this.sentinel = new Sentinel(true, extendsRange, position, dim); diff --git a/Fabric/src/main/java/at/petrak/hexcasting/fabric/recipe/FabricUnsealedIngredient.java b/Fabric/src/main/java/at/petrak/hexcasting/fabric/recipe/FabricUnsealedIngredient.java index d8f864aa..a564d85b 100644 --- a/Fabric/src/main/java/at/petrak/hexcasting/fabric/recipe/FabricUnsealedIngredient.java +++ b/Fabric/src/main/java/at/petrak/hexcasting/fabric/recipe/FabricUnsealedIngredient.java @@ -33,7 +33,7 @@ public class FabricUnsealedIngredient extends Ingredient { .filter((it) -> it != DatumType.EMPTY && it != DatumType.OTHER) .map((type) -> { ItemStack newStack = stack.copy(); - NBTHelper.putString(newStack, DataHolderItem.TAG_OVERRIDE_VISUALLY, SpellDatum.GetTagName(type)); + NBTHelper.putString(newStack, DataHolderItem.TAG_OVERRIDE_VISUALLY, SpellDatum.tagForType(type)); return new Ingredient.ItemValue(newStack); })); this.stack = stack; diff --git a/Forge/src/main/java/at/petrak/hexcasting/forge/network/MsgColorizerUpdateAck.java b/Forge/src/main/java/at/petrak/hexcasting/forge/network/MsgColorizerUpdateAck.java index 1ba69e08..960c36ce 100644 --- a/Forge/src/main/java/at/petrak/hexcasting/forge/network/MsgColorizerUpdateAck.java +++ b/Forge/src/main/java/at/petrak/hexcasting/forge/network/MsgColorizerUpdateAck.java @@ -25,13 +25,13 @@ public record MsgColorizerUpdateAck(FrozenColorizer update) implements IMessage var buf = new FriendlyByteBuf(buffer); var tag = buf.readAnySizeNbt(); - var colorizer = FrozenColorizer.deserialize(tag); + var colorizer = FrozenColorizer.fromNBT(tag); return new MsgColorizerUpdateAck(colorizer); } @Override public void serialize(FriendlyByteBuf buf) { - buf.writeNbt(this.update.serialize()); + buf.writeNbt(this.update.serializeToNBT()); } public static void handle(MsgColorizerUpdateAck self) { diff --git a/Forge/src/main/java/at/petrak/hexcasting/forge/recipe/ForgeUnsealedIngredient.java b/Forge/src/main/java/at/petrak/hexcasting/forge/recipe/ForgeUnsealedIngredient.java index 797fcb9c..17d38831 100644 --- a/Forge/src/main/java/at/petrak/hexcasting/forge/recipe/ForgeUnsealedIngredient.java +++ b/Forge/src/main/java/at/petrak/hexcasting/forge/recipe/ForgeUnsealedIngredient.java @@ -30,7 +30,7 @@ public class ForgeUnsealedIngredient extends AbstractIngredient { .filter((it) -> it != DatumType.EMPTY && it != DatumType.OTHER) .map((type) -> { ItemStack newStack = stack.copy(); - NBTHelper.putString(newStack, DataHolderItem.TAG_OVERRIDE_VISUALLY, SpellDatum.GetTagName(type)); + NBTHelper.putString(newStack, DataHolderItem.TAG_OVERRIDE_VISUALLY, SpellDatum.tagForType(type)); return new Ingredient.ItemValue(newStack); })); this.stack = stack; diff --git a/Forge/src/main/java/at/petrak/hexcasting/forge/xplat/ForgeXplatImpl.java b/Forge/src/main/java/at/petrak/hexcasting/forge/xplat/ForgeXplatImpl.java index 9bc84169..941d663d 100644 --- a/Forge/src/main/java/at/petrak/hexcasting/forge/xplat/ForgeXplatImpl.java +++ b/Forge/src/main/java/at/petrak/hexcasting/forge/xplat/ForgeXplatImpl.java @@ -124,7 +124,7 @@ public class ForgeXplatImpl implements IXplatAbstractions { @Override public void setColorizer(Player player, FrozenColorizer colorizer) { CompoundTag tag = player.getPersistentData(); - tag.put(TAG_COLOR, colorizer.serialize()); + tag.put(TAG_COLOR, colorizer.serializeToNBT()); if (player instanceof ServerPlayer serverPlayer) { CapSyncers.syncColorizer(serverPlayer); @@ -175,7 +175,7 @@ public class ForgeXplatImpl implements IXplatAbstractions { boolean allowed = tag.getBoolean(TAG_FLIGHT_ALLOWED); if (allowed) { var timeLeft = tag.getInt(TAG_FLIGHT_TIME); - var origin = HexUtils.DeserializeVec3FromNBT(tag.getLongArray(TAG_FLIGHT_ORIGIN)); + var origin = HexUtils.vecFromNBT(tag.getLongArray(TAG_FLIGHT_ORIGIN)); var radius = tag.getDouble(TAG_FLIGHT_RADIUS); var dimension = ResourceKey.create(Registry.DIMENSION_REGISTRY, new ResourceLocation(tag.getString(TAG_FLIGHT_DIMENSION))); @@ -186,7 +186,7 @@ public class ForgeXplatImpl implements IXplatAbstractions { @Override public FrozenColorizer getColorizer(Player player) { - return FrozenColorizer.deserialize(player.getPersistentData().getCompound(TAG_COLOR)); + return FrozenColorizer.fromNBT(player.getPersistentData().getCompound(TAG_COLOR)); } @Override @@ -197,7 +197,7 @@ public class ForgeXplatImpl implements IXplatAbstractions { return Sentinel.none(); } var extendsRange = tag.getBoolean(TAG_SENTINEL_GREATER); - var position = HexUtils.DeserializeVec3FromNBT(tag.getLongArray(TAG_SENTINEL_POSITION)); + var position = HexUtils.vecFromNBT(tag.getLongArray(TAG_SENTINEL_POSITION)); var dimension = ResourceKey.create(Registry.DIMENSION_REGISTRY, new ResourceLocation(tag.getString(TAG_SENTINEL_DIMENSION))); @@ -207,7 +207,7 @@ public class ForgeXplatImpl implements IXplatAbstractions { @Override public CastingHarness getHarness(ServerPlayer player, InteractionHand hand) { var ctx = new CastingContext(player, hand); - return CastingHarness.DeserializeFromNBT(player.getPersistentData().getCompound(TAG_HARNESS), ctx); + return CastingHarness.fromNBT(player.getPersistentData().getCompound(TAG_HARNESS), ctx); } @Override @@ -217,7 +217,7 @@ public class ForgeXplatImpl implements IXplatAbstractions { List patterns = new ArrayList<>(patternsTag.size()); for (int i = 0; i < patternsTag.size(); i++) { - patterns.add(ResolvedPattern.DeserializeFromNBT(patternsTag.getCompound(i))); + patterns.add(ResolvedPattern.fromNBT(patternsTag.getCompound(i))); } return patterns; }