TCDCommons is a Minecraft modding API library that features its own GUI system and various events and hooks for the game, as well as utilities that may be useful to mod developers. This API's main purpose is to help optimize and speed up the development of mods, as well as to avoiding re-writing the same code for every mod that needs to do similar things. Please note that because this mod is a library, it may not offer useful front-end features to the user.
As mentioned earlier, the primary goal of this API is to enhance and accelerate the development of Minecraft mods, while also eliminating the need to rewrite redundant code for each mod that performs similar tasks. In the beginning, the initial purpose of this API mod was to provide a better the GUI system that's easier to work with, but it has since evolved to include various useful events, hooks, and utilities that may be commonly used.
This API mod is primarily used by TheCSDev for developing Better Statistics Screen.
Screens on the in-game HUD for visual enhancement. Please note, these HUD Screens are for display purposes only and cannot be interacted with via user input.Class during the saving and loading of configs.With the GUI system, you can create your own custom GUI menus, in a simpler way that allows for more customization and flexibility.
In the vanilla GUI system, we use Screens. In this API's GUI system, we use what's called TScreens.
All GUI components, including TScreen, and GUI widgets, can be found in the following package:
io.github.thecsdev.tcdcommons.api.client.gui.
Below we will create an example TScreen implementation, with a simple button on it that does something when it's clicked:
import io.github.thecsdev.tcdcommons.api.client.gui.screen.TScreen;
import io.github.thecsdev.tcdcommons.api.client.gui.widget.TButtonWidget;
import net.minecraft.text.Text;
public final class ExampleTScreen extends TScreen
{
/*
* `super` takes a `Text` argument for the screen's title
*/
public ExampleTScreen() { super(Text.literal("Example TScreen")); }
/*
* This is where the screen initializes its GUI elements.
* We will add the button widget here.
*/
protected final @Override void init()
{
//create the button, and center it on the screen
final var button = new TButtonWidget(
(getWidth() / 2) - 50, //the button's X position. we will center it
(getHeight() / 2) - 10, //the button's Y position. we will center it
100, //the button's width
20 //the button's height
);
//define a text for the button
button.setText(Text.literal("Click me"));
//now let's do something when the button is clicked
button.setOnClick(btn ->
{
//print a simple message to the console
//when the button is clicked
System.out.println("Hello World!");
});
//and finally, let's add the button to the screen
addChild(button);
}
}Now, we need to open the screen and show it to the user. To do so, we use MinecraftClient#setScreen(Screen) (on Fabric), and we use TScreen#getAsScreen() to obtain the Screen reference. So our final code will look like this:
final var tscreen = new ExampleTScreen();
final var screen = tscreen.getAsScreen();
MinecraftClient.getInstance().setScreen(screen);The event system allows you to not only listen for various events already provided by this API, but it also allows you to create and invoke your own custom events.
Below is an example of how you can create your own event, register and unregister listeners, as well as invoke the event:
import io.github.thecsdev.tcdcommons.api.event.TEvent;
import io.github.thecsdev.tcdcommons.api.event.TEventFactory;
public final class ExampleEvents
{
/*
* This is how we create a custom event using this API.
* Note that this event system is similar to Architectury API's event system,
* but with some tweaks and additions done to it, for more flexibility.
*/
public static final TEvent<Runnable> eSomething = TEventFactory.createLoop();
public static final void registerAndUnregisterListener()
{
//we first define the listener that will be invoked when the event is invoked
final Runnable listener = () -> { System.out.println("The event was invoked."); };
//then, this is how we can register it
eSomething.register(listener);
//and then, this is how we can unregister it
eSomething.unregister(listener);
}
public static final void invokeEvent()
{
//we invoke the event by obtaining the "invoker",
//and calling the functional interface's main function
//(in Runnable's case, the main function is `run`)
eSomething.invoker().run();
}
}I appreciate and value everyone's contributions to this mod, whether it involves translating the mod, offering feedback, or providing valuable suggestions. If you’d like to contribute, here are some ways you can get involved:
For more information about this mod, please visit this mod's repository page.
For information about this mod's license, please view this mod repository's license page.