All Classes and Interfaces
Class
Description
Page that has a hex pattern on it
A bit of wrapper information around an action to go in the registry.
Add a random preset hex to the ancient cypher, and select a random variant.
Slap a random per-world pattern on the scroll.
Note that this just keeps track of state, actually giving the player the elytra ability is handled
differently per platform
AltioraLayer<M extends net.minecraft.client.model.EntityModel<net.minecraft.client.player.AbstractClientPlayer>>
This is the interface to implement if you want to override the behaviour of an Operator pattern like ADD, SUB, etc.
This is the class responsible for managing the various Arithmetics that are in use, deciding based on the current
stack which Operator should be called, etc.
Default impl for an impetus, not tecnically necessary but I'm exposing it for ease of use
No-op BE just to have a BER
Does absolutely nothing on Fabric; the flammable block registry is for that.
Environment within which hexes are cast.
The order/mode stacks should be discovered in
ExtractMedia component that extracts media AFTER the call to
CastingEnvironment.extractMediaEnvironment(long, boolean)
if the input is <= 0 you should also probably return 0 (since media cost was already paid off)ExtractMedia component that extracts media BEFORE the call to
CastingEnvironment.extractMediaEnvironment(long, boolean)See
BlockEntityAbstractImpetus, this is what's stored in itAn iota storing a continuation (in essence an execution state).
The kind of sound that plays after a cast.
A snapshot of a pigment item and its owner.
this is LITERALLY a copy of NullIota but I can't see how to do it any better, i hate java generics
HexAPI.EntityVelocityGetter<T extends net.minecraft.world.entity.Entity>
On forge: these are setup in ForgeHexInit
On fabric: it's a mixin
Why don't we just use the same API mod on Forge and Fabric? Beats me.
Stores the registry for continuation frame types, some utility methods, and all the types Hexcasting itself defines.
Items which can cast a packaged Hex can implement this interface.
Stores the registry for iota types, some utility methods, and all the types Hexcasting itself defines.
Dodge protected ctor
A simple wrapper around the parts of HexPattern that are actually used for rendering.
static points making up a hex pattern to be rendered.
Implement this on a block to make circles interact with it.
An interface that mimics some methods of IForgeBlock.
Items that store an iota to their tag can implement this interface.
Used to determine whether a given set of iotas on the stack are acceptable types for
the operator that is storing this IotaMultiPredicate.
Used to determine whether a given iota is an acceptable type for the operator that is storing this.
Item that holds a list of patterns in it ready to be cast
To get the armor model in;
On forge: cursed self-mixin
On fabric: hook in ClientInit
TAG_OP_ID and TAG_PATTERN: "Ancient Scroll of %s" (per-world pattern preloaded)
TAG_OP_ID: "Ancient Scroll of %s" (per-world pattern loaded on inv tick)
TAG_PATTERN: "Scroll" (custom)
(none): "Empty Scroll"
TAG_OP_ID: "Ancient Scroll of %s" (per-world pattern loaded on inv tick)
TAG_PATTERN: "Scroll" (custom)
(none): "Empty Scroll"
more like IHexplatAbstracts lmaooooooo
This is a wrapper for
SpellList.Grab the pattern from the registry
Provide the pattern(s) manually
Items which can store Media can implement this interface.
Kinda like
CastingEnvironment but for executing mishaps.Sent server->client to spray particles everywhere.
Sent client->server when the player finishes drawing a pattern.
Sent server->client when the player finishes casting a spell.
Sent server->client when the player opens the spell gui to request the server provide the current stack.
Sent S->C to have a wall scroll recalculate its pattern, to get readability offset.
Sent client->server when the client shift+scrolls with a shift-scrollable item
or scrolls in the spellcasting UI.
An iota with no data associated with it.
A helper class for defining
Operators of two iotas.A helper class for defining
Operators of one iota.> no this is a "literally copy these files/parts of file into your mod"
> we should put this in patchy but lol
> lazy
-- Hubry Vazcord
An immutable wrapper for pattern colors.
A class holding settings for shaping and positioning patterns.
Settings for positioning the pattern and defining its general size/render area.
Settings for stroke and dot sizings.
Controls how the pattern is zappified.
Possible things we find when trying to match a pattern's shape.
The shape exactly matches a pattern that isn't altered per world
I've never met that pattern in my life
The pattern is the right shape to be one of the per-world patterns.
The shape matches a special handler
Used for displaying patterns on the tooltips for scrolls and slates.
Pehkui doesn't publish an API jar so we do this BS
Items which can be used as a colorizer can implement this interface.
RecipeSerializerBase<T extends net.minecraft.world.item.crafting.Recipe<?>>
I'm sick and tired of not having a result class god dammit
Maps angle sigs to resource locations and their preferred start dir so we can look them up in the main registry
Save this on the world in case the random algorithm changes.
Use this to make things display when the player looks at things with a Scrying Lens.
Return the lines displayed by the cursor: an item and some text.
Predicate for matching on a block state.
A null sentinel means no sentinel
A purely-documentative annotation.
Special handling of a pattern.
Given a pattern, possibly make up the special handler from it.
Society if java actually had first-class function support
Items that have multiple different otherwise identical visual variants can implement this interface.
Special case for villagers so we can have biome/profession/level reqs
Helper methods for rendering patterns in the world.