ChampionAsh5357

My only comment would be on OpenClientScreenMessage as the Minecraft instance can just be obtained inside the method itself. This is still 'safe' I believe, but we should avoid calling anything that might only be available on the client that is not isolated in a different class. This is my opinion as it still won't be loaded unless on the physical client.

From what I understand, this is not the correct way to use DistExecutor. For the case where you can't supply a runnable or supplier, DistExecutor#unsafe* should be used instead. This will supply a runnable of what you want to execute (e.g. () -> () -> //Do things). This does not verify nor guarantee that the code is completely safe to access; however, if the runnable executes another method that is isolated in a different class, it is 'safe' since classloading will not occur. So, the proper way to implement the code above is DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> ClientScreenManager#openScreen).

You can look at what implements the interface. You can also infer which classes might need to know the light value (for example, the world). To be able to statically project an object, you need to take the position and subtract it from the projected view.

Well, it might help if you enable the lightmap associated with the block. Also, why not render a block using BlockRendererDispatcher? Finally, why do you even need to render a custom version of a block?

Try without RenderSystem::blendColor. If not, try disabling the depth test (disableDepthTest) and depth mask (depthMask). Remember that these should be reset during the teardown phase.

What version is this?

Please link a paste to the gradle log from the erroring build process.

Villagers can be added via VillagerTradesEvent while wandering traders via WandererTradesEvent.

Yes, as you can see it has the obfuscated name which translate to its unique srg name and then finally the mapped name. You will need the srg name as your parameter. The static keyword makes the field/method available at class level meaning you do not need an instance to grab the associated value. So, a null value can be passed in instead.

Setting the alpha state does not enable transparency. You need to set up the blend function in such a way such that the rgba inputs are being blended correctly. This is why I mentioned TRANSLUCENT_TRANSPARENCY.

Well, yes. Now there's a bunch of new caveats. If you really want to attempt this, a similar mod named Hyperbox by Commoble accomplished this. That's probably the best I can do as the process of actually handling is quite complicated and problematic at times.

Ah ok. Well, that would be quite complicated. You would need to create a new key for every dimension you create and store them somewhere for easy access. You would also need to construct the ServerWorld, add a world border listener, update the world cache, and send a packet to the player with the required information. This also requires ejecting players from broken worlds or proper teleportation when needed. There are about a hundred other checks that are also necessary. Although, a question I might ask is that why make this a mod? This seems like more a server plugin.

Apologies, you have to be on the forge discord to access the bot for the commands. Now, if you wouldn't mind answering my question about your knowledge in Java and reflection.

How familiar are you with Java and reflection? Also, read the javadocs on the method, do not supply a mapped name and instead the associated srg name (which can be obtained from forge-bot via '!mcpf <mapped_name>).

You cannot dynamically register new dimension within JSON. I think I'm going to need a clearer goal of the task at hand. What are you trying to accomplish on the user end?

The object itself is immutable, the data can be mutable. The issue is that the field accessor is private. ObfuscationReflectionHelper#getPrivateValue can be used to obtain the Map to which you can put the value during common setup.

Please provide the repository and a code snippet of where your exact problem is as your question seems to be worded incorrectly.

It seems your testing if the value changed using the logger, which will always be the default value when first initialized. This is not to mention that the entirety of the code is reaching across sides and still trying to force load the config.

Please link your repository then. I'm questioning a few things regarding that TextConfig class and context surrounding what you are using on the client and server configuration.

Something that cannot be mentioned on the forums as coremodding isn't supported here.

I would try increasing the size of the model to around 0.005 compared to a flat plane.

Since this mod is uses a library that is present within Forge, yes it is possible. Although, you should prioritize handling these items in events if possible.

I would say don't do that and just register multiple dimensions. Each 'world' is a dimension, so having multiple 'world' with the same dimension qualifier will make it problematic to handle when saving or loading data. However, you can have two JSONs holding the same information under different dimension names.

Whenever trying to use RenderSystem, a good reference is the RenderState class as it shows you the startup and teardown methods needed to handle what you need. In this case, I would suggest looking at RenderState#TRANSLUCENT_TRANSPARENCY. As a side note, whenever possible, IRenderTypeBuffer should be used to handle drawing objects to the screen, although in this case it is not that applicable.

On the Forge discord, the following appears as a trick: Official documentation: https://docs.oracle.com/javase/tutorial/ Absolute basics with an interactive editor: https://www.codecademy.com/learn/learn-java Ongoing online course with assignments: https://java-programming.mooc.fi/ As a side note, the language on the forums should be English and that you will not receive support until you have a proper grasp of Java. Good luck, and I hope you come to ask more questions once you have spent a good amount of time learning and practicing the language.