#1.21.2 Snapshots
1 messages · Page 3 of 1
the recipe only copies the components of the input item
Also apart from the input item the transmute recipe type only allows for 1 other item
interesting block properties got a small refactor
DirectionProperty is gone and now EnumProperty is more configurable when its initially created
to specify which enum consts it uses
all property classes look to have been finalized and ctors made private
Well that’s boring
Useful but boring since I would think copying data components would be a given for stack based recipes
thankfully that won't affect my packing tape logic
I mean in the sense that my logic was already not using DirectionProperty :P
I have been 
fabricord people said that shulker boxes now have an item tag? so that should be removed from the c tags
They do, yeah
Deprecated for a version (along with including them in the vanilla tag)?
Can't remember how we've handled tag removals like that in the past
@lucid totem They did exactly what I suggested last week for the index lookup in EnumProperty \o/
Neat
For c tags we need to discuss with fabric
Dispensers be doin' stuff o.o
They just moved the minecart dispense behaviour to a proper class from an anonymous one in the minecart item
I don’t be doing anything
Oh neat, Player#canDropItems is a thing now
Seems prime for a small patch there
Hey Mojang, if you're listening, a playersMayDropItems gamerule would be kinda nice
It's overriden in both server and local player for drop spam throttling
So you can have a survival player in a map, but they can only do inventory management at chests/etc
if, on top of a no drop items gamerule, we also got a rule to limit the available inventory slots, we could make one-block-at-a-time with vanilla
Oh lawd
You may only have armor, main hand, and offhand
Get creative.
Subtle:
DirectionProperty is gone, replaced by EnumProperty<Direction>
Resident Evil moment
And done with the primer: https://github.com/ChampionAsh5357/neoforged-github/commit/984b5c84829f4f1a1e8f2dc0413bfd9476740ea4
player drop speed attribute, set to 0 to disable
They are? Well, the holder of the consume effects is
yeah, I'd have just expected them to be similar to the enchantment effects ig. though, I suppose those are doubly split into components and separate non-component registries as well. just strange how it's shaping up rn
probably to have consume effects applied in a visible, reliable order; totem of undying's death_effects clear all status effects and then give a couple of effects afterwards
I mean, doesn't stop them from making a DataComponentList or DataComponentLinkedMap
the ConsumeEffect.Type is just the same stuff as a DataComponentType
minus the cache
<@&1067092163520909374>
https://www.minecraft.net/en-us/article/minecraft-snapshot-24w39a
New version detected: 24w39a.
WHAT
here we goooooooo

Bundles are no longer experimental
a snapshot so good they released it three times
BoatType enum might be gone?
I would have thought that map_invisibility_equipment would've been a data component not an item tag.
Where were you when Boat Split
Looks like it, yeah, they are all individual entity types now
One less enum to make extensible
dammit, Snowman is regenning the commits again!
hmm smol one
i hate it
MATYYYYY
finally, caves and cliffs is over
I've had an issue open of someone wanting me to make the rafts in Just A Raft Mod extendable so they could register more raft types for modded trees using KubeJS


because maty didn't configure it to
Why would it not?
The custom runner should have the cache?
note that it isn't decompiling all the versions again; the cache still exists for those
but because the repo got into a bad state due to the two interrupted workflows -- because the n8n workflow executed thrice in succession -- it's recreating all the commits
Automated automation is hard, apparently
it's an idiosyncrasy of Snowblower; it pulls down the entire repo, and force-pushes the existing commits up in batches of 10
but if it gets interrupted while doing that for the old, previously-made commits, then the GH repo contains only the first few old commits
and it has to recreate all the old commits
n8n thonks for the workflow: put the 'success' part of the existing workflow into a new workflow, into which is passed all the info (modified time, versions)
and set that new workflow to store all successful executions
The Flattening, part N+1
extensibleEnumCount--
I
in 211 of 281
Finally, boats are good
a lot of server-exclusive methods were moved from Level to ServerLevel apparently
that seems to explain a lot of the diff
Yeah, because then a ServerLevel is passed as context to a lot of Entity methods so that those methods don't have to (ServerLevel)level() everywhere
Screen#showsActiveEffects is a nice little override
Looks like a ton of recipe book handling got turned into AbstractRecipeBookScreen, too - simplifies a lot
LocalPlayer#hurt is gone, RemotePlayer#hurt is now #hurtClient -- so we got some MP changes there too
They remove Herobrine again?
No that's only in full release changelogs
Ahhh right 👍
Herobrine now knows how to use non-oak boats now, though
So be warned.
ByteBufCodecs now has LONG 🎉
Good
Looks like that's because the clientbound time packet now encodes the game, day, and tick times
(It's a record now)
New interface, ServerEntityGetter, extending the existing EntityGetter -- so yeah I'd agree with Tech, Mojang is shuffling around client/server logic a decent bit here
Notably, ClientLevelData no longer seems to have a copy of the game rules
tech how far is the split?
I am supposed to review it still
gradle-wise or client/common-wise?
Client common, the thing we are waiting on to start kits
let's not wait for that
it will make rebasing stuff painful, so I'd rather delay it as much as possible
Sounds reasonable. I'd be down to waste a few hours tonight, hammering out rejects, if we decide to start with kits
lol
we should try running the workflow with the buildsrc plugin to see if it's faster 😅
(and if -Pupdating works)
anyway; off you go 😄
👌
202 rejects
Time to have some fun 😄
fuck I have two hackmd accounts -_-
one with github and one in my password manager
might be useful, might not be
let me already claim custom ingredients 😄
I'm gonna claim the client package 😅
I have not looked but I'm willing to do block stuff
Block is something I'm likely gonna touch as well because it has some interactions with the rendering rejects I'm fixing
remember to push sometimes 😄
isn't it the fields that are optional?
Currently digging through the weeds of baked model rendering and all the fabulous/non-fabulous render type differentiation is gone \o/
🤨
All the methods for baked model rendering that deals with DefaultVertexFormat.NEW_ENTITY render types (mainly items and falling block entity) previously threw around a boolean flag everywhere. That's entirely gone
One example are these two methods: https://github.com/neoforged/NeoForge/blob/1.21.x/patches/net/minecraft/client/renderer/ItemBlockRenderTypes.java.patch#L41-L54
Yup
The move of LightTexture computation to a shader might fuck over some people as IDimensionSpecialEffectsExtension#adjustLightmapColors() won't work anymore (at allowed per-pixel light color adjustments)
The "entity render state" stuff also has some interesting consequences
Guys don't forget to do regular commits and push them
Xfact for later, we normally do one (or more) commits per reject file
I can't remember that we ever did one commit per reject. It also just doesn't make sense with how intertwined these rejects often are
Since i joined the porting team we mostly did 1 commit per reject file
that doesn't make sense
we commit stuff in batches of relevant stuff
looks like some people were splitting stuff by patch; others not
Probably the greatest typo in this codebase 
I turned myself into a partial tick, Morty!
oh are we porting kits now
guess i should go clone it and help out
that's right
I think the
[ "minecraft:planks", { "type": "modid:whatever", "data1": 42 } ]
syntax won't be implemented
instead it will be
{
"type": "neoforge:compound",
"children": [ "minecraft:planks", { "type": "modid:whatever", "data1": 42 } ]
}
Seems reasonable. The verbosity doesn't hurt IMO
yes, it's acceptable
hmmm
I just realized that { "type": ... } will conflict with custom holdersets 
oh because ingredients now use holdersets
yes
Yeah 😄

the patches are still simpler because all the Value crap is gone
(i.e. the complexity level went from 8 to 6 out of 10 or so
)
nice
well 6/10 is still a lot
unfortunately we cannot remove the custom ingredients, because NBT-aware matching is important
but we need a new name for the ingredient type field
that is one option, yes
imo it's the easiest option
yes
let's do ingredient_type
damn the NonNullList<Ingredient> getIngredients() getter is gone from Recipe
we'll have to patch some shit like that back in 😒
(otherwise mods like AE2 or JEI have no way of guessing possible inputs...)
we'll see later
I feel like it shouldn't be necessary to patch back in -- after all, what does the vanilla recipe book use now? Shouldn't JEI and company be able to do whatever it does?
PlacementInfo?
(I'm also generally against patching methods onto classes that modders would be forced to implement in general. If a modder implements the vanilla contract for a class, it should be enough)
complex recipes simply aren't supported by the guide book
yes; that is unfortunately hardcoded to Holder<Item> (at the moment, at least), and custom recipes just return PlacementInfo.NOT_PLACEABLE
huh? how do shaped recipes with empty slots work
Shaped recipes are a "shape" defined with placeholders and then a map of those placeholders to ingredients
There's no ingredients for spots that don't have anything in them
it is a little annoying that you don't have context to whether something is a tag ingredient or a regular ingredient, etc, anymore
Seems like the proper approach here is to see about extending PlacementInfo instead of patching in a method that would mean that a Recipe implemented against the vanilla contract is invalid in neo-land...
So I suppose, how hard does making PlacementInfo provide more functionality look?
...Though actually, wait -- can you give me an example of a recipe that is placeable but where using Holder<Item> isn't enough to do so? I suppose stuff with custom NBT ingredients or whatever, right... hmm
If that method is patched back in, there should be some very clear docs noting that mods cannot rely on recipes necessarily implementing it (and maybe directing them to PlacementInfo stuff as a fallback?)
how do we handle when vanilla introduces a new system
for something we previously patched in?
vanilla has a new conversion thing in mob Mob#convertTo
to convert from 1 mob type to another
we patch in our conversion events everywhere
vanilla tries to convert an entity
i feel these events should now be moved from all the various entity classes
to now live inside of the convertTo utility
Probably, yeah
would maybe make sense to work on that tho after the initial porting(?)
(apply rejects like normal for now, move them to mob convert later?)
Yeah
ahh we pushed at same time xfact 
What's new about Mob#convertTo 
wait thats not new? i thought it was added in one of the recent snapshots
but anyways i think rather than patching in conversion events everywhere
throw them in the conversion api vanilla has
less patches, same functionality
I am veeery certain we have the patches because of edge cases convertTo misses...
it's why I did several of the patches
Well there's a new object
ConversionParams
which is backed by an enum ConversionType
unless vanilla changed to actually call convertTo for these cases, the patch stays
vanilla is using it everywhere now
It doesn't really help with .Pre, I think, because the ConversionType isn't invoked until the new entity has already been created
events patched in are callbed right before and after vanillas convertTo
even slimes are using it for splitting on death
and Mob#convertTo is still virtual, so we don't have a good entrypoint to call pre
It's still possible we can improve the API with vanilla's new changes
I can have a look once snapshot time is over™️
I'm gonna call it quits for tonight, I've stared at these stupid patches long enough. Some notes:
RenderNameTagEventwill need to be split into "allow rendering" and "do custom rendering" due to the "entity render state" changesRegistryAwareItemModelShapershould not be needed anymore as the vanillaItemModelShapernow stores aMap<ResourceLocation, BakedModel>to support the "item model" data componentRenderPlayerEventcan no longer subclassPlayerEventdue to the "entity render state" changes (satisfies #1266)LevelRenderer#outlineEffectRequestedneeds to be moved to aFrameGraphSetupEventdue to the frame graph system- Separately rendering non-translucent particles may not be viable anymore due to the frame graph system
AbstractFurnaceBlockEntityburn time handling patches need handling ofFuelValuesChunkDataEvent.Load/Saveneed to be reconsidered (chunk object and NBT data are not simultaneously accessible anymore)
The only one of those that I've implemented is theRenderPlayerEventchange
A side-note on the last point: due to ChunkSerializer not existing anymore (saving happens via SerializableChunkData now), the associated patch did not even produce a reject, which seems very error-prone to me
hmm, that last one might want @glass perch's attention
a patch not being considered a reject when the original file that the patch modifies doesn't exist
I think DiffPatch doesn't add the .rej file extension if the file that is being patched was removed and the workflow for starting a kits branch checks for .rej
it's just a matter of running the steps locally
fun fact: we have the same problem over the network
I suppose we'll use a size of -1000 for custom ingredients 
over the network I am using a prefix of -1000 for now
for custom ingredients it is "ingredient_type": ...
Has Neo considered prefixing custom keys with its own namespace like Fabric does?
we have in other contexts 
Load conditions, for example
yeah, we don't do it consistently atm
I'll do fluid ingredients once everything compiles and runs; for now I think they should still compile and run using the old code
recipes are now deserialized in the prepare phase of the reload listener
this is likely problematic for resource conditions
looks fine for tags though
yeah it's fine, tags are now loaded before the reload listeners are even instantiated
If we're chaning it anyways, could we prefix it with neoforge:?

currently looking at IContext
I had a quick look at that last night and noped out 😄
hehe 😄
it got changed quite a bit; now vanilla has a thing called PendingTags
which contains a registry lookup that you can use to get tags
however it looks like the contents of the tags are not available yet (imagine the bugs that people will run into!) 😄
Oof, yeah, that's going to be interesting
oh apparently the tags are just updated in the HolderLookup.Provider already 🤨
so we might be able to remove IContext entirely
I think we can remove it, but I'll keep it around for now since it's reasonably easy to adjust
Sounds good
can't wait for mojang to start using virtual threads so we can stop with all the future soup
Hehehe
That class doesn't exist in my dev env 
right
we've had this problem before
the magic command is git clean -dxf -- projects/base/src projects/neoforge/src
(to remove all untracked files)
be careful 😄
My magic is to just nuke the local folder 
lame 😄
Ah, so that's where that annoying command source error came from 
yup 😄
Not sure this is the best solution to deal with the mob conversion changes with respect to the mob splitting event, but it should do the trick: https://github.com/neoforged/Kits/commit/89cf439f9de26521283dd7e8636f06fd16feaf42#diff-40e51d77c70913b0520424a1c1d6ef6667bd980da035b914fca7985e9dbdb75dR217-R229
IShearable just defers back to Shearable for the relevant vanilla entities
oops, accidentally wiped everything in the directory that is not in Git 😅
We'll have to check how this interacts with ReloadableServerRegistries' use of LootDataType#conditionalCodec() when calling scanDirectory() since that would technically create a conditional conditional codec: https://github.com/neoforged/Kits/commit/6f27c2c51c94b67c671a4cc92f5092b11f1fb81b#diff-d6014723b910eeacb32858ad287febb5aa70a3013236c3bbfce18342ef9788eaR52
you're a machine, I don't have enough motivation for all this nonsense 😄
😅
I wonder if we should have started the port earlier 
Not sure to be honest, yesterday's snapshot did break quite a few things with the server level stuff in entities, so it might have actually been the perfect time
the later we start, the less total effort it is
but it is more effort to get it to compile
Definitely
what 😄
did mojang change Registry#get from nullable to optional
Looong =
thanks I hate it
brain wants to stab me for using single equals sign for comparison
Due to Registry now extending HolderLookup.RegistryLookup and therefor HolderGetter, the value lookup is done with Registry#getValue() now and Registry#get() now does what Registry#getHolder() did before
Hmmmm ok
Hmm, the effect curing via ConsumeEffect is a bit annoying. To do this properly with the EffectCures we'd need to register a custom ConsumeEffect.Type but that would break vanilla compat. Patching the two ConsumeEffects related to this is also not viable because the one used by milk is called ClearAllStatusEffectsConsumeEffect and the one used by honey bottles (RemoveStatusEffectsConsumeEffect) takes a HolderSet<MobEffect> which we can't populate from an EffectCure.
Mods will probably just have to use ModifyDefaultComponentsEvent to replace the specific ConsumeEffect held by the Consumable component on the milk bucket and honey bottle (with custom holdersets for removal) to add or remove their effects from the cleared ones
somewhat related, but are we going to add IItemExtension methods for all these component queries? or should people just mutate the component accordingly whenever they change some other NBT?
Hmm, good question. I'd say leave it as-is for now with no extension methods and then expand on it when someone comes up with a good reason for an extension method
yeah of course; but long-term it's not a viable solution to add an extension method for every single thing
Yeah, somewhat keeping these extensions to a minimum is definitely necessary
On a completely different note: the model baking changes are very
worthy. We should probably look into nuking UnbakedGeometryHelper.bake() and instead patch BlockModel#bake() directly. Our ElementsModel in particular feels pretty pointless over SimpleBakedModel, the only difference is that the latter doesn't get the root transform treatment (which is slightly broken anyway at the moment)
wtf is that ElementsModel 
I approve of this idea
A SimpleUnbakedGeometry that produces a SimpleBakedModel with the only difference to the vanilla construction of the latter being that the former applies root transforms
To me it looks like one of those "avoid larger patches at all costs" kind of thing from the past
🤷
There is no world where this is actually the case...
What was the build.gradle line to change the max errors again?
-Xmaxerrs <count>
Perfect, thank you, just need to find the correct place in Neo's build script 😅
Yeah, that's more realistic 
where did you place it, i tried adding it yesterday but couldnt get past the spread players error
lol I had the same
In the allprojects block in the top-level build.gradle
if we were running with idea it would be nicer
I'm gonna try to get rid of most of them in one run, shouldn't be too bad all things considered
That took ever so slightly longer than I anticipated, but I have a main menu and a test world. The loading overlay will need some fixes as it currently produces strobe lights 
My last three commits make it compile and run but I have not handled all rejects yet. I'd like some additional looks over these three commits in particular:
- Untangling model loading (removes
ElementsModelandUnbakedGeometryHelper#bake()): https://github.com/neoforged/Kits/commit/ce9cfbee2059f4fb8ffda173de27b8b56b391ca1 - Making it actually compile and run: https://github.com/neoforged/Kits/commit/3d2e48397dae962ba64a2a1f5d4451de4233ad5e
- Fixing interactions between tag binding and registry freezing after snapshot application (on this one I'm really not sure it's the best solution): https://github.com/neoforged/Kits/commit/aa3da9c8a238776ffbf75b61ca297a33c637ced2
I've left quite a few TODOs in the code which I'll have to go over tomorrow
⚠️ flashing image warning
is this caused by all the render changes or is my graphics dieing?
That's a bug in the overlay. I'm not quite sure yet why it happens though
ah ok so not my graphics dieing xD
Yup. This issue is what I was referring to with strobe lights in my comment above 😄
oh you mentioned it already.. i didnt read xD just saw the "make it compile" commit and clicked run xD

also create test world, is that a vanilla thing?
Yes, that was added in a recent snapshot
Yup
gonna have to look and see how that works see if it sets the normal things i usually set
I'm gonna go get some sleep. I would appreciate comments on the three commits I linked above, there is very likely some stuff that could be done cleaner
what did the test world do again?
iirc, a superflat 'redstone ready' preset world with daylight cycle, mob spawning, and weather cycle gamerules disabled
That's epic
right, that's good
is that button behind the sharedconstants flag? that's wonderful
imagine the button changing to load test world if there's only one world in the folder and that's a test world
You should instead pass the cli flag to auto join the world on start
that's too much work
I'm currently looking at the remaining minecart rejects and I'm considering ripping out the entire minecart extensions. A lot of them make no sense with the experimental minecart behaviour, some are replaced one-to-one by new vanilla methods and a lot of the targets of the patches are moved to the MinecartBehaviours. We can always add back hooks that make sense for the new minecart implementation.
Any objections?
I'd be in favor of ripping them out to get the thing to compile as long as we revisit prior to the release
Well, it does already compile and run 😄
Oh right true
But we do need to get rid of the remaining rejects, so it's either painfully reimplementing them or ripping this out entirely
We can rip it out, it's a super old API
yeet 🛒
Maybe do it in a separate commit so we can always go digging back for it
Yeah, I'll make a dedicated commit for it
@red jungle shouldn't this be !ingredient.isCustom(): https://github.com/neoforged/Kits/blob/406eaf5ff4c52dbce594c42982e4e92bb96a93d5/src/main/java/net/neoforged/neoforge/common/crafting/IngredientCodecs.java#L56?
With the isSimple() check it currently also catches custom ingredients that wrap vanilla ingredients or other simple custom ingredients and therefor blows up on client sync since it tries to sync the empty placeholder HolderSet<Item> used by Ingredients holding a custom ingredient
I'm experimenting with the furnace fuel burn time stuff right now and my current approach is to build the datamap from the vanilla FuelValues during datagen (the generated file is unchanged) and then take over the runtime creation of FuelValues to instead populate it from the datamap. On the server I can do this directly in the two places where vanilla builds it (MinecraftServer constructor and MinecraftServer#reloadResources()). On the client I can't do that because datamaps aren't synced yet in the ClientPacketListener constructor, ClientPacketListener#handleUpdateTags() is only called for the tag sync after /reload but not for the initial sync since that happens during config phase and DataMapsUpdatedEvent only fires on the client for dedicated server connections. My current solution on the client is to hijack ClientPacketListener#handleUpdateRecipes() since that is called for both initial connection and reload.
Can anyone see any flaws in this idea or think of a better one?
The check is correct but it needs to write the items manually
The intention is to send the items directly if the ingredient is simple
So basically change the vanilla stream codec to use Ingredient#items() instead of accessing the values field directly?
Yeah, that's going to be fun because items() returns a List<Holder<Item>> 😅
Though, I guess for the sync a direct holder set should be fine, right? I can make one of those from a List<Holder<Item>>
Ah yes of course
This does the trick in my testing: https://github.com/neoforged/Kits/commit/826c1c20d7b2a2c6397dfd0f9aa269704394ca9a. I opted to use a little helper to preserve the ability of vanilla ingredients to sync a tag key instead of the resolved entry list
They sync the tag key? I didn't know that
The HolderSet can be a HolderSet.Named which is synced as a tag key instead of the resolved entry list
That's really cool
I wonder if we should always sync custom ingredients via their type then
To optimize the network footprint
vanilla clients go brrrrr
Fun fact: we could make it depend on the connection type
That's a great idea actually
I was about to say 😄
Sure, I can look into it in a moment
How would you prefer to deal with complex custom ingredients and vanilla clients? Try a best-effort vanilla sync or disconnect?
Wait they finally fixed this?
In the past the client always seemed to get a massive list of items for tag ingredients
"always seemed"? that's literally how it worked 
Yes
Tags are synced before recipes since 1.20.5, so it was finally possible to solve this
Cool
I only need to do hacks for 1.20 & 1.21 then
I was actually just looking into the problem yesterday
Implemented this as described, if someone has a better idea, feel free to change it: https://github.com/neoforged/Kits/commit/29741afee2719416c123ad9932b110dac6d65309
Here ya go: https://github.com/neoforged/Kits/commit/11fe5153ffd872d0c9137c83e6ed9a9a6c23469b. I've opted to have it sync custom ingredients on a best-effort basis to vanilla clients for now, though, if desired, we can always add back a check for simple ingredients and throw an exception when trying to sync a complex custom ingredient to a vanilla client
It's late as hell again, but we are now down to 11 rejects and 6 patches with lost targets and all of them have a comment outlining what might be done about them
Looks good!
You're crazy 😅
disclaimer: i haven't looked at new vanilla code
is there a reason we don't just ignore the furnacevalues and have the method return the data map
@round perch I've restored the two-pass particle rendering, it's not that bad: https://github.com/neoforged/Kits/commit/9c530732e9d0dab5c8083c01cf1f10a2ed36bd8f
👌
Do we know anything about what's causing the strobe effect during the loading overlay yet?
Nope, no idea yet
did someone fix the 3 datagen files that were changing?
(c:boats tag, something with the piglin predicate, and the fuel data map)
c:boats still shows an error during world load so probably not
The fuel datamap doesn't change anymore since last night
something something shulker box item tags
vanilla's added it now, so the c tag seems redundant
but that PR should probably be coordinated with fabric people
The data we load from the datamap fits neatly into the vanilla system, so it seems like a good idea to me to embrace the vanilla system that is almost guaranteed to be data-driven itself soon
yeah I suggest we just fix the existing tags
and let TG have fun with changes 😄
ok I'll look at the other files then
What do we want to do about all the elytra hooks? Flying is now controlled by the GLIDER data component
DataComponentType<Unit> GLIDER
😒
ok so it's a combo of the glider component and the equippable component
Mhm
it just does a hurtAndBreak on the component while gliding
this kinda sucks
in MI I have a diesel jetpack that acts as an elytra
it doesn't take damage so that's pretty easy
for my use case at least, we can remove the hook 😄
How does it render? Is it an armor piece that uses the armor model hooks or is it a dedicated layer?
it's really ugly atm, it just uses the vanilla armor model with a custom texture
Ah, makes sense.
The armor model hooks also got a significant hit since they entirely lost their entity context. Some of them still get the entity render state and some currently get nothing 
there is now #minecraft:boat so I'll leave only that in #c:boats (along with #forge:boats, which will probably get cleaned up at some point)
I love mojang's consistency btw
plural names? never heard of that 
lol
the advancement replacement fails because of the new PIGLIN_SAFE_ARMOR tag, it's just a matter of updating the provider
The overlay issue makes me think somebody's math is lerping with only 0 and 1 instead of the actual value
I generated patches to look at our diff vs vanilla but not seeing anything obvious yet
the flashing?
Wait we completely replace the loading overlay
Yes
Yeah, that was my thought as well 😄
Vanilla tag is only passenger boats. Not all boats
So prob just c:boats/passenger (for clarity), c:boats/chest, and then have those two tags plus vanilla tag in c:boats
really
It’s for the boat with a goat advancement
I mean, I was talking about the shulker boxes, but thanks for the info :p
Shulker box if a perfect copy of ours, then yeah we can yeet ours and make legacy tag detector tell people to switch to vanilla
Assuming we trust vanilla not to yeet their tag like they did with music discs
Caused by: java.lang.IllegalStateException: Unable to convert criterion serialization and replacement: Missing tag: 'minecraft:piglin_loved' in 'minecraft:item'
at TRANSFORMER/[email protected]/net.neoforged.neoforge.common.data.internal.NeoForgeAdvancementProvider.lambda$replacePlayerPredicate$21(NeoForgeAdvancementProvider.java:206)
nightmare
how does this even work in vanilla 
hmmm the problem is that we are trying to parse stuff in the datagen
The armor model/texture hooks lost a lot of context: https://github.com/neoforged/Kits/commit/c6b67e93abd131b753e1ee2707377ceebef26e40
Ok so I've figured out the strobing is related to some state that gets changed by the display window
doesn't seem to be the rest of the opengl calls in NeoForgeLoadingOverlay, I replaced it all with rendertype stuff and I still see strobing
but commenting out displayWindow.render sort of fixes it
Looking some more into the elytra hooks:
- The texture hook in
ElytraLayercan be handled with the model parameter of theEquippabledata component and a custom equipment model JSON, so I'd suggest removing it IItemExtension#canElytraFly()would be salvageable, we'd just need to decide whether that hook should allow bypassing theEquippablecomponent check inLivingEntity.canGlideUsing()IItemExtension#elytraFlightTick()is toast unless we accept that it only gets called once every second and on a random applicable item instead of all of them
keeping canEltraFly without elytraFlightTick is weird
Yeah
dogshit but it works: https://github.com/neoforged/Kits/commit/ec50455d5aca9dd421de474e192514fa374ace93
stupid BAMBOO_CHEST_RAFT doesn't have "boat" in its name so I missed it in CapabilityHooks -_-
What would your suggestion be? Nuke it and let people find a way to reinstate it if they really need it?
yes
👌
Tech, while you're looking at recipes and advancements: do you mind looking into the ShulkerBoxColoring reject? It's probably a candidate for recipe replacement as well
ItemUseAnimation is extensible now, adding back the UseAnim.CUSTOM entry with a patch is not an option anymore because the enum is part of a data component now and therefor synced
Hmm,
ing on ChunkDataEvent.Load/Save right now and not entirely sure what to do with them. There is no point anymore where both the chunk and its serialized NBT data are accessible, for loading it would require capturing the NBT data to pass it between future stages and for saving it would require capturing the chunk in another future stage's lambda. I can see three solutions and all of them suck:
- Move the events to the place where the chunk and its
SerializableChunkDataare present. This prevents actually writing anything to the chunk data unless we patch an additional "custom data" compound into that record - Move the events to the place where the
SerializableChunkDatais being converted from and to NBT data. This prevents accessing the chunk, so there's no way to do anything with custom data read from the chunk's NBT data and no way to get the custom data from the chunk to write it to NBT (unless you do global storage, which, uh, 🤮) - Add additional
ParseandWritesub-events that require the user to manually pass data fromParsetoLoadand fromSavetoWrite, which is anywhere between really painful and actually impossible since load/save happen on the main thread while parse/write happen on the background executor
The first option is probably the least awful
Though we could of course also just tell people to use data attachments on chunks and go with the first option without the additional "custom data" tag. The benefit of the first option would be that attachments are safely accessible at both injection points since they both run on the main thread
We can tell people to use attachments IMO
Ok, then I'm gonna finish up the docs cleanup on these events and then push option one without the custom data tag
You'll notice I tend to like removing redundant hooks 😄
There's a chance we'll have to add some back
I do like removing them as well 😄
Probably a good idea, yeah
what about the dye + dye -> dye recipes?
I think it makes sense to also override those
Sounds reasonable to me
OK so let's override the basic coloring recipes + the following:
src/generated/resources/data/minecraft/recipe/cyan_dye.json
src/generated/resources/data/minecraft/recipe/dark_prismarine.json
src/generated/resources/data/minecraft/recipe/gray_dye.json
src/generated/resources/data/minecraft/recipe/light_blue_dye_from_blue_white_dye.json
src/generated/resources/data/minecraft/recipe/light_gray_dye_from_black_white_dye.json
src/generated/resources/data/minecraft/recipe/light_gray_dye_from_gray_white_dye.json
src/generated/resources/data/minecraft/recipe/lime_dye.json
src/generated/resources/data/minecraft/recipe/magenta_dye_from_blue_red_pink.json
src/generated/resources/data/minecraft/recipe/magenta_dye_from_blue_red_white_dye.json
src/generated/resources/data/minecraft/recipe/magenta_dye_from_purple_and_pink.json
src/generated/resources/data/minecraft/recipe/orange_dye_from_red_yellow.json
src/generated/resources/data/minecraft/recipe/pink_dye_from_red_white_dye.json
src/generated/resources/data/minecraft/recipe/purple_dye.json
all looks pretty reasonable to me
Agreed
I'll just note this in the docs of ChunkDataEvent.Save for now, but modifying data attachments in that event won't be reflected in the final serialized chunk data
I removed the reject
👌
I got to go, I'll take care of the Ingredient reject later (the single hunk that remains of it)
there's a chance that empty tags just fail to deserialize now and it's not needed anymore, we'll see
The empty holder set check in the constructor only handles "if right" which is the entry list, it doesn't check the tag
yeah, but there's a chance that the HolderGetter rejects unknown tags
Ah, yeah, that sounds possible
running tests needs some fixes 😄
I gave up on the overlay for now btw
Tech having fun instead of writing code smh
embeddedt, do you have an idea how to reinstate the PostChain patch?
You would indeed be right, it refuses to parse empty tags: [20:35:14] [Worker-Main-53/ERROR] [minecraft/SimpleJsonResourceReloadListener]: Couldn't parse data file 'minecraft:andesite' from 'minecraft:recipe/andesite.json': DataResult.Error['Missing tag: 'c:cobblestones/normal_typo' in 'minecraft:item'; Not a JSON object: "#c:cobblestones/normal_typo"': Optional[net.minecraft.world.item.crafting.ShapelessRecipe@28bb6a83]]
That's great! Then we can remove the reject, and drop the barrier check in hasNoItems. I suppose we might even delete hasNoItems entirely.
I'm gonna leave that for later you and go play some games 😄
You too 😄
I don't fully follow how the whole postprocessing chain system works yet
(this goes for 1.21.2 and the older versions too)
Fair enough
Nevermind, I may have spoken too soon. I only tested with a non-existent tag (i.e. missing tag file) but not with an existing but empty file. The latter instead outputs this and keeps the invalid recipe: [Render thread/WARN] [minecraft/RecipeManager]: Recipe minecraft:andesite can't be placed due to empty ingredients and will be ignored
Yeah, I definitely spoke too soon. The recipe manager complains that the recipe is unplaceable but doesn't actually do anything to prevent using the recipe, so you get this nonsense...
What is that picture supposed to say?
Empty tag ingredients should never match any stack
It seems to currently match anything except an empty slot 😅
Okay, the plot thickens: in a shaped recipe (which uses Ingredient.testOptionalIngredient() for ingredient matching) only an empty slot matches an empty tag file, but in a shapeless recipe (which uses StackedItemContents#canCraft() for ingredient matching) anything except an empty slot matches an empty tag file
Nametag render event reinstated: https://github.com/neoforged/Kits/commit/56d2444742b52ba35629df1cddaa2f27dfe811d2. The event names are kinda meh, so if anyone has a better idea, feel free to change it
Sorry for late primer, it should be ready sometime within the next 24 hours, assuming I don't get stuck on something again
Pfff they did it again
reproduced yeah
wtf
didn't we have a similar issue before?
it's mojang's fault most likely
I wonder whether there is a Mojira ticket for this since it should be reproducable in a completely vanilla game with just a datapack
they keep getting it wrong
thinking about https://github.com/neoforged/NeoForge/issues/841
yes that was one of the mistakes in the 20.2 custom ingredients implementation
which we did not do again
no idea, let's see
They should really just let ingredients be, lol
I wonder what motivated this new refactor anyway
Does the related issue for shaped recipes accepting exclusively empty have a ticket?
Likely the ability to send tag ingredients as tag keys instead of resolved lists over the network
That would be nice
as usual the Mojira mods don't actually read and just close the issue if it doesn't follow an exact template
sigh
no... just edit the bug report... it's automatically reopened
The point is that the required information is present, it's just not done exactly the way the template specifies
1. (Explain what needs to be done for the issue to happen)
2.
3.
Observed Results:
(Briefly describe what happens)
Expected Results:
(Briefly describe what should happen)```
Templates are mostly for regular users, the average developer will provide enough info even without a template
Normally, in a bug report, there's always the datapack to reproduce the bug...
and a video/screenshot
Bruh dumbass mod
attached a datapack and a correction to the report
Okay done. Mainly boat restructuring and levels being replaced by server levels
wdym?
why would an empty slot match an empty tag file -_-
Because it does, ask Mojang how that makes sense 
...
I can't reproduce it (with shaped recipes)
and fwiw the following test is false:
(the ingredient is an empty tag)
this is false too
Hmm, I can't reproduce it anymore either. No clue how I managed to make it happen 
we do love some heisenbugs
try
- first session in a brand new world
- first session in a brand new world after /reloading
- existing world
- existing world after /reloading
what would happen if we changed recipes a bit more
depending on the changes, some people may be very happy, or very annoyed
well, as long as it is not world gen and tree gen
;P
now i'm tempted to change the role icon for Problem Causers to an explosion 
oh no
[Reference to](#mojira message) #mojira [➤ ](#mojira message)This ticket has just been resolved as Fixed!
In 1.21.1 and before, ingredients of recipes were synced as an list of Item Stacks (with all components / nbt data) which was changed in 24w33a to only sync item types. While this functionality was never used by vanilla server, custom servers (and plugins/mods) used it to show custom ingredients (with all their components) in recipe book's ghost slots/grouped recipe preview. As ghost slot displaying (but not how it's displayed) and actual slot matching logic is running server side, there were no notable side-effects of components being present on the client (aside of visuals that is). With this functionality no longer being present, recipe book loses it's usability on servers that add a lot of custom content with custom recipes.
Resolved as Fixed <t:1727775678:R>
Future Update
22
3
<t:1724143326:R>
Inb4 ingredient predicates
imagine 
I think I found the explanation for the flashing screen
the problem happens when rendering the mojang logo
earlydisplay does glBindTexture(GL_TEXTURE_2D, textureId); and glBindTexture(GL_TEXTURE_2D, 0);
however, blaze3d isn't aware of this, so a call to RenderSystem.bindTexture(...) might not update the texture
you know why it flashes?
because every client tick (not frame) the active sprites are uploaded
which causes a different texture to be bound, and therefore forces a rebind
so every client tick you get a single red frame, then it's back to black 
fixed!
/**
* TODO: does it make sense to keep this?
* ItemStack sensitive version of {@link Item#getEnchantmentValue()}.
*
* @param stack The ItemStack
* @return the enchantment value
*/
default int getEnchantmentValue(ItemStack stack) {
return 0;
}
can probably be removed
in the spirit of the other stuff that got data component-ed
I wanted to ask @dull heron about that since he's mister enchantment.
If you remove it, don't forget to delete the EnchantmentHelper reject.
probably fine to remove that yeah
brewing recipes???
TNT CRAFTING
Those still aren't data-driven?
haha no
wild
and every time someone tries to add datapack brewing to fnorge, it turns out to be a big can of worms, and they decide that the worms are better off being inside the can and put the lid back on
In what sense?
Making them data-driven is inherently complicated, or just patching it into Minecraft instead of Mojang doing it is complicated?
the fundamental issue here is that brewing has to work on neoforge-vanilla and vanilla-neoforge connections
ahh
Plus the issue that the way brewing recipes work in vanilla is... already its own can of worms before you even start attaching datapack stuff to it
the way brewing recipes work in vanilla is actually remarkably friendly to moving it to a data system
the main issue is just keeping vanilla compat
Placebo retains the ability to add additional brewing mixes via datapack, but does not make any attempt to interact with the existing ones
well... sorta. Neo's brewing recipe API makes it not terrible
But without that there's a lot of fun hardcoding going on
well, we also hardcode all the recipes when we use the brewing api 
Yes but you don't severely limit what the input item can be at least 
Vanilla doesn't strictly limit it either, it just retains a List<Ingredient> of valid containers
That but instead of the two TNTs, its MOJ and ANG
I love it
tempted to throw this in a server resource pack and see how long it takes people to notice
You'd need more than just the texture, the TNT model shares all 4 sides
But I did this in Blockbench in like 10 minutes, so.. simple enough
Fairly simple change tho
Just gotta change the texture reference for two sides
rotate it 90 degrees and read it as ANG MOJ
time for custom renderer
Late snapshot today
i wonder if we get the new features
they were pretty complete at live it would make sense to add them now behind an experiment
#blameBoq or something
just disable recipes for the snapshot, what could go wrong

Wouldn't be the worst thing. Though, might as well change the title screen to just say "Mine" at that point
<@&1067092163520909374> ^
There it is
IT BEGINS

woooo
it begins
yeah we now @inland vault
/rotate??
WHAT
New version detected: 24w40a.
we can rotate entities via command now 🎉
which means we can rotate players 
(without teleportation tricks)
Couldn't you do that already?
iirc, no...?
I thought that was possible through the data entity set command
at least, without constantly teleporting a player to a player an entity
players are the one exception to the data command
you can read, but can't modify
unfortunately
ah got it
Is it really different than teleporting with relative xyz and then different rotation? Pretty sure it has a sync variant for packets that only really does rotation
https://github.com/neoforged/Snowman/commit/7ebe2a8929d4f12098dc7c0ea873d3f40ac32df7
for those with snowman perms
you're telling me it finished already!? impossible /j
Well not that they stated 🙃
Or did you look at the diff?
Bevause they could've rewritten an entire system
Oh boy!
i can’t see the diff unfortunately
quite a chonk
oh lord
such a shame I can't /ride leash knots anymore
Lots more realms stuff..
Remember that boq said something about recipe changes
And there do seem to be a fair number of those
Recipes have resource keys now
so where is the blog post
So they're probably in the same realm as loot tables
RecipeBookCategories is gone o.o
this sounds interesting.
hopefully that's somewhat generalized
Oh please tell me they turned recipes into a proper registry that would be great
added trail particle with the following options:
color - the color of the trail
target - the position of the target for particle to reach
this gonna be good for mapmakers
Apparently the new tag is what controls the pumpkin overlay now
hopefully
o.o
oh 

Direction now has getPositive and getNegative methods
huh, I did not expect them to do this as an experiment
WardenEmissiveLayer is now LivingEntityEmissiveLayer
Mob mods rejoice on that one
I love generalization
Well, rewriting the recipe book extension is going to be annoying
They're back to using static final fields again
oh thank god they finally split up renderItemDecorations
It now has renderItemBar, renderItemCount, and renderItemCooldown methods
Kinda wish those were static and took in the pose, but progress
why must they be private tho, neo for sure gotta at those public
Or, well, Direction.Axis
oh, so are recipes a reloadable registry now?
And it has getDirections now too
Is it known if this is data driven in datapack or just plain code?
No, they're a fake registry, like functions

I assume it's just done in animatetick like fire
18 compile errors for neoform
they probably made it data driven
fingers crossed
they don’t hardcode much these days since they want fully data driven blocks
public SlotDisplay display() {
return (SlotDisplay)this.values.unwrap().map(SlotDisplay.TagSlotDisplay::new, $$0 -> {
return new SlotDisplay.Composite($$0.stream().map(SlotDisplay.ItemSlotDisplay::new).collect(Collectors.toUnmodifiableList()));
});
}
Only change to ingredient
Pretty cool though
That's exactly what we need for AE2 etc
Actually it's annoying that we need to manipulate both the slot displays and the items in compound ingredients
In case you want to update Kits to 40a tonight, I won't be able to help you, I'm out with friends
Recipe proprety sets are just...why right now
They need a transformer or something because it's just hardcoded nonsense
according to patbox, recipes are no longer synced on the network
I think it's to the benefit of a lot of people if neoforge reimplements that and enforces the contract of network serialization on recipes
I can confirm that recipes are no longer synced in full, but some data about them still is. E.g. ingredients, size (for shaped recipes), result, etc.
But for recipe viewers that's definitely not enough info
in particular, mods like JEI and EMI need this data for plugin developers to have a reasonable time developing their plugins
Well it is for shapeless, but not shaped
it would really negatively impact the workflow if modders themselves needed to manage network syncing for obvious reasons and would also be bad if recipe viewers had to make their own implementations, the latter particularly for duplication issues and requiring the mod on the server (instead of just neo)
jei can just sync the full recipes themselves I guess 
a lot of jei isn't even recipe recipes
JeiRecipeCodec 
though it would have to run serversided
I didn't read the post above mine and they said everything I did first
I agree with Emi that it would be good for NeoForge to implement this itself
recipes don't have a serialization guarentee, or at least won't soon
I believe they still have a deprecated one
for the current snapshot an implementation of JEI or EMI can sync, but I have very little faith it will remain, and if both are loaded get ready for 2 massive wasteful packets
I mean, a Codec is enforced, because that's how they're parsed
Just the StreamCodec may go away soon
the maintenance burden is pretty small, hopefully, neo implements the vanilla recipes based on current vanilla sync, an abstract method is added and modders only need to migrate to the new serialization before they notice it's gone
Random restriction is random
the codec is deprecated according to patbox
The StreamCodec is deprecated
The Codec is not
The Codec is how recipes are loaded from json files
I'm gonna be real I don't touch codecs do they also handle packet serialization
aha, then yes that
But you can use a Codec to serialize
You can serialize an object to a packet using a Codec
It's just less space efficient
You just have to convert to NBT and then send the full NBT structure
they shouldn't, at least, you can send it as json/nbt through the friendly byte buf
But bandwidth goes woooo
that packet already explodes on modest instances
Then again, I don't think Neo should sync recipes to the client just because
at worst just add a call if a mod wants recipes synced, I guess
both JEI and EMI are installed in most modpacks, and both would likely sync these themselves, the average case network cost is higher
Isn't EMI installed on top of JEI?
no? it's a standalone mod
Why would you install both then?
codecs are also just slower
JEI hands over plugin registered recipe data
The recipe is still sent it seems actually, just in a completely different way
EMI functions fine without JEI
it in no way depends on it, and I can't expose JEI's api through my own
this does not solve the problem of stream codecs going away
that's bad
Sure
how many neoforge instances run without JEI or EMI
But I don't think that enforcing a random restriction is good either
Your APIs could very well require registration of a StreamCodec
at worst you can allow mods to opt in to serialization and then if they can't access their recipes on the client it's their fault
The recipe is still sent
Oh well, then no problem at all
It's just sent differently
Instead of the recipe being sent directly, RecipeDisplay objects are sent instead
It's basically a stripped down version of a recipe that eliminates some server-specific info, such as advancement data
yeah, I don't know exactly what recipe viewers need from the recipes, but there's a lot of display info still sent to clients
The notable difference is that SlotDisplay objects are sent instead of Ingredient objects
You can think of them like client-sided ingredients
arguably nicer
which morning did you mean 
Yeah they're pretty nice
plenty of recipes lack these, though
in vanilla, campfire cooking at least
and stuff like smithing is just lacking any of the input information
it also looks like recipe displays don't have ids...
stream codecs are going away ?
aiui, no, just recipe sync changed
We need to finish the 39a rejects first, and make sure the automated tests pass at least
did you forget 
Oh yeah, not great
It would be nice if NeoForge synced this info
I don't see anything wrong with requiring recipes to be serializable via codec/streamcodec, but I don't know if Neo force-syncing recipes unconditionally is a good idea. There are certainly people that choose to play without a recipe viewer; there's no point forcing them to incur the overhead of deserializing recipes
it is fine if there's an api call to trigger the sync
But even that has implications, e.g. it allows hacked clients to bypass limited crafting or whatever the gamerule is called
uh, I don't think so? crafting is still handled by the server
I don't know if anyone in modded actually relies on hiding recipes for fairness
Yes but in the current snapshot the client doesn't know the full set of recipes if they're locked, correct?
The hacked client would have to try crafting literally every possible combination by force, and could only do so with stacks the player has
not sure but that's even more reason to sync recipes
uh, no, if limited crafting is on, server will not recognize a recipe that player does not have in recipe book
Yeah, the RecipeManager IIRC specifically checks if the player has access to the recipe before returning it
what changed in snapshot is that the client will only receive the recipes in recipe book, limited crafting or not
So only way in vanilla to get all recipes is /recipe give @s *
Oh so we need to sync machine recipes that are not in the recipe book now 
Or add them to the recipe book
IIRC the main reason mods don't use the recipe book is we don't have patches to make displaying 400 different types of recipes nicely like we do the creative tabs
You could add a packet for a client to ask for all recipes displays
and nobody ever implemented that because jei/emi/fmi exists
For sure yes
This is IMO a good thing long term - clients shouldn't need to have access to literally everything under the sun. Recipe viewers can either include an optional server component if they really want to "sync recipes like it used to be", or just dynamically build their "recipe tree" based on what recipes the client has unlocked, listening for recipe unlocks from the server
That might be somewhat of a lazy solution though 😄
Also not compatible with vanilla - I suspect if something like JEI goes that route, players will be opening bug reports asking "why can't I look up the recipe for an iron chestplate?" when they don't even have iron ore
yeah, that's gonna be annoying
The recipe viewer showing only unlocked recipes sounds interesting tbh
sometimes you have an end goal, but no clue how to get there 
And would stop issues where servers try to hide recipes as a mechanic where recipe viewers now cheat through
It sucks for heavy modded
It's been a thing in a bunch of mods for a while; Thaumcraft did it a lot for example
Depends how it's set up with limited crafting
I mean, if it's gonna be part of the optional server components for those mods (perhaps with a config option), I think it's fine, it just shouldn't be removed outright 
Yeah, Advancements unlock recipes
In any case, I suspect the only real solution is to build one recipe graph for the client recipes, and then build the graph of server recipes based on a view of those client recipes, with the appropriate overrides from the server, and somehow indicate to the player whether a recipe comes from the server or the client
(at least for recipe viewers that want to show "all recipes", even locked ones)
The advancements can lead to lots of spam by lots of mods. Could neo do a more efficient system where you can mark a recipe as always discovered on client

very high res, yes yes
are recipe advancements mandatory now
we need less of those
Every recipe has always generated an associated advancement iirc
no?
I thought someone told me this the other day 
you don't have to, but you get warns iirc
Only in datagen
Ah
oh, the vanilla recipe provider might require them, I don't use that though
because it requires advancements 
recipe advancements are just extra cruft sent to the client in modded, nobody's ever asked me to add them for my mods
I had people ask me to fix my mod’s recipes in recipe book
So yes people look at book in modded
But the question is, how much tradeoff are we doing if we make all mods required to have advancements for their recipes
We just traded recipe packet spam for advancement packet spam plus inventory scanning for the advancement
It's like 5 minute job to make some recipes always available
Just make it opt-in
Vanilla just never had a use case for it
Well, maybe except for that magic crafting table recipe
magic crafting table recipe? O.o
Crafter secret inside name at Mojang
yeah, it's a magic coffee table at out office where we do mines and crafts
arts and crafts
I don't like the idea of going back to the old behavior when you clearly wanted to change how things work
Maybe we'll do it, but it makes sense to explore the solution space a bit first 😄
I need to check how the new system handles syncing non-item data (e.g. fluid inputs/outputs for a recipe, or energy usage, etc)
SlotDisplay is the client equivalent of Ingredient
The goal was to not send all the recipes all the time
Opt-in is fine. Even all recipes is fine, though you have probably hit packet size limit multiple times
NeoForge has support for spreading out packets over multiple packets. Or at least it was planned
We have automated packet splitting for that
I think looking into patching better mod support to the recipe book is a good first step
it's been something people have been poking about for years now, it's just... nobody's needed to really do it yet
Yeah, split packets were always there
"mojang: 4 MB compressed should be enough"
"modders: I see that as a challenge"
and then like, orthagonal to that, people have also been poking about making some sort of unified api for recipe viewers
Yeah resourcepack sending will be fun for one of my mods, heh (though I'll probably do some kind of proxied web server instead, as that works with Vanilla clients)
and the reason we don't have that is it turns out there's always less common ground between recipe viewers than everyone assumes at first
but now maybe the recipe book can be the common ground?
lacks way too much information to be a common ground
eh, not that much has changed, instead of recipe server sends a display, which is just bit of hint for player about recipe without constraints of being actually craftable.
So instead of sending ultrapowertechmagicmod:unltimate16x16recipe type, just send "yeah, it's a shaped 16x16 recipe, those are inputs, those are outputs", anyone wants to display that?
how do I send the power consumption etc 
just serialize it
power is the number of slots
Well crafting_shaped is a type of RecipeDisplay, so you'd create your own RecipeDisplay that also sends that information
recipedisplays sound typedispatched?
minecraft:recipe_display registry
make a recipe display type, register, make a recipe that returns it, fire it over network and hope something on client side is willing to render it
don't have to limit stuf to slots, it's upcasts all the way
hey, mojang made a common recipe viewer API before we did
ooop, sorry, "patterned switch"
ohhh I see
I mean, it kind of is, it's just missing the ID
minus the viewing part, apparently? 
it's an api, not an impl 
that's quite cool actually
well there's also an impl I guess
recipe viewers can probably switch to using the recipe displays 🤨
what information are they lacking?
What information do they lack other than a persistent ID? Which they do definitely lack
id, remainders, and implementation specific data like cook time, ingredients for smithing recipes, every campfire recipe
remainders are part of Items, not Ingredients
not in practice
If a mod has a recipe that destroys the item rather than returning the remainder, sounds like a bug
no? what if you want water bucket + spider eye -> bucket of wet eye
yeah I just updated jumbo furnace a couple months ago to respect the remainders... in items
people make recipe specific remainders all the time
"recipe specific remainders" are just "a second output"
wouldn't those things be part of the recipe display registration?
not for reasonable display metric
implementation specific details would certainly be in the display
although... FurnaceRecipeDisplay doesn't seem to send the burn time
if we need implementation specific details that aren't easily retrievable by the subclass then we can just do something like IRecipeDisplayRenderer<T> like menuscreens
yeah, and the way to get remainder info is to let the recipe tell via display you and not dig into every actual recipe implementation
since the only interface right now is "getReminderAfterCrafting"
the burn time is constant though, isnt it? 
no
anvil smithing recipes only send the output
furnace recipes can specify how long it takes to cook the furnace recipe
how have I missed this... 
That is data that is not sent that would be useful to receive
anvils use recipes now??? 🤨
if vanilla doesn't need it we could patch it in 
actually no
that would nuke vanilla connections, probably
Current contents of displays are based on vanilla needs, doesn't mean they can't change
I'd like to eventually display cooking time in vanilla, but it turns out tooltips are hard
makes sense
in principle nothing stops mods from including in the RecipeDisplay whatever info they want to use on the client-side JEI/etc integration
you can't really add stuff to vanilla displays without causing compat headaches, but yes there is nothing stoping mods from including their recipe id and all required info in their displays
vanilla displays might need special tricks, or a side-channel
and then you just give jei their IRecipeDisplayHandler<T> or whatever
devs will still need to handle the hookup between whatever recipe representation and recipe viewer data though
yes
re technici4n
I guess re "this is a recipe viewer agnostic api"
looks like registry replacement leftovers to me
yeah you still need the RecipeDisplay -> EmiRecipe or whatever mapping to be provided by the mod
hmmm sadly this is still needed for registry sync stuff
we still have these rejects
many of them are related to removeEffectsCuredBy
maybe we keep these for 23w40a; I'll update Kits tomorrow
The remove method is deprecated for removal, it was indeed related to registry replacement. The add method is there to fill the block-to-item map in our registry callbacks. We might be able to fix this in a similar way to other "registry submaps" where we replace the vanilla map with ours instead of using a separate map, though I'd have to look into the specifics tomorrow.
Edit: just saw your fix, that looks fine as well
I'm honestly considering ripping the cure system out. I don't see any way of implementing that without breaking vanilla network compat
#566276937035546624 message hmmmm
boq going to completely break recipes again because we're complaining
next week they'll be a whole new type of registry and JEI wont be conceivable
I will add this to the build.gradle:
tasks.register("genPatches") {
dependsOn tasks.unpackSourcePatches
}
25 new reject files for 24w40a
finally they got rid of hasCraftingRemainingItem
now they just check if getCraftingRemainder is empty or not
TODO comment above that method was only 8 years old, give us a break
now time to get rid of separate matches and assemble? 😄
I'd almost be tempted to say we should add it back if they do
like, match gets called a lot, and assemble might be expensive for custom recipes
I'll make a TODO
isn’t there already one?
see you in 8 years
why are y'all speaking like this?
why not™️
good point
Because emphasis is nice
isn't this emphasis
this is how you know the conversation is very serious
I see
in old html <em> did italics, and <strong> did bold
to me a full line in italics is an aside
while a single word of phrase is emphasis
I went to that place
That's also my take
Define “old”? It’s still that way isn’t it?
Holder.equals perhaps?
I don't think holder has an equals implementation
Yea but the deprecation is vanilla
it still works, yes, but I don't think it's recommended to use those tags since they are not well-defined in terms of what the tag should look like
I think that’s the point isn’t it? If you want to emphasize something put it in <em>
And then the web designers decide how emphasized stuff looks
looking at the docs, looks like it is useful, for screen readers
so the voice speaks with emphasis too 
I guess <em> is still useful
if you want actual emphasis and not just visual italics
Correct
<i> is italics without semantics




