4.1 KiB
Entrypoints
Entrypoints are a specific type of extension that allows mods to inject code that will run as the game is starting up. They can be thought of as like the main()
function in a full Program, and are primarily used for adding things to registries, declaring callbacks and events, and other tasks your mod needs to do once during startup.
MainExtension
The MainExtension
entrypoint contains the core of your mod's initialization code. MainExtension
will run during the startup sequence on both the server and the client, and thus should be populated with things like registrations (i.e. of blocks, items, entities) and events that are triggered on both the server and client side.
The first step to creating a MainExtension entrypoint is to create a class. This should usually be in the root package of your mod, but does not have to be. For this example, we will create a class called ExampleInit
that implements the interface MainExtension
:
package com.example.examplemod;
public class ExampleInit implements MainExtension {
...
}
Once this class is created, add it under the [frog.extensions]
table in your frog.mod.toml
file with the key init
:
[frog.extensions]
...
init = "com/example/examplemod/ExampleInit"
...
The interface MainExtension
contains one method, called onInit
. It takes one ModProperties
object and returns void
. We will implement this method by adding a Logger and printing a message:
package com.example.examplemod;
import dev.frogmc.frogloader.api.mod.ModProperties;
import dev.frogmc.froglib.entrypoints.MainExtension;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public final Logger LOGGER = LoggerFactory.getLogger("ExampleMod");
public class ExampleInit implements MainExtension {
@Override
public void onInit(ModProperties mod) {
LOGGER.info("ribbit world");
}
}
Now, when we launch the game with the example mod installed, we will see that message sent when our mod is initialized.
ClientExtension
The ClientExtension
is very similar to the MainExtension
in its function as an entrypoint, except it will only run if the mod is installed on the client. This is primarily used for modifying the behavior of rendering, like through custom models or renderers, as well as keybinds and other interactions that are only processed on the client side. To create a ClientExtension entrypoint, the process is very similar; first, we will create a class implementing the interface ClientExtension
. This class should be annotated with the @ClientOnly
annotation so that it is only loaded into the classpath on the client. Usually it should be placed in a package specifically for client-related classes.
package com.example.examplemod.client;
import dev.frogmc.frogloader.api.mod.ModProperties;
import dev.frogmc.frogloader.api.env.ClientOnly;
import dev.frogmc.froglib.entrypoints.ClientExtension;
@ClientOnly
public class ExampleClientInit implements ClientExtension {
@Override
public void onClientInit(ModProperties mod) {
...
}
}
This should also be included in the [frog.extensions]
table in your frog.mod.toml
, under the key client
:
[frog.extensions]
...
client = "com/example/examplemod/client/ExampleClientInit"
...
ServerExtension
ServerExtension
is very similar to ClientExtension
in implementation, except it runs only on the dedicated server. It does not run on the internal server. To create a ServerExtension entrypoint, create a class implementing ServerExtension
annotated with @ServerOnly
.
package com.example.examplemod.server;
import dev.frogmc.frogloader.api.mod.ModProperties;
import dev.frogmc.frogloader.api.env.ServerOnly;
import dev.frogmc.froglib.entrypoints.ServerExtension;
@ServerOnly
public class ExampleServerInit implements ServerExtension {
@Override
public void onServerInit(ModProperties mod) {
...
}
}
Add this to the [frog.extensions] table in your
frog.mod.tomlfile, under the key
server`:
[frog.extensions]
...
server = "com/example/examplemod/server/ExampleServerInit"
...