Add basic configs

template/{{ common_path }}/src/main/java/{{ package_path }}/api/config/{{ classname }}Config.java.jinja

@@ -0,0 +1,90 @@
+package {{ package }}.api.config;
+
+import {{ package }}.{{ classname }};
+
+import java.util.Collection;
+
+/**
+ * Platform-agnostic class for statically accessing current config values.
+ * If any of the config types (common, client, server) are not needed in your mod,
+ * feel free to remove anything related to them in this class and platform-specific config implementations.
+ */
+public class {{ classname }}Config {
+    private static final CommonConfigAccess dummyCommon = new CommonConfigAccess() {
+    };
+    private static final ClientConfigAccess dummyClient = new ClientConfigAccess() {
+    };
+    private static final ServerConfigAccess dummyServer = new ServerConfigAccess() {
+        @Override
+        public int getCongratsCost() {
+            throw new IllegalStateException("Attempted to access property of Dummy Config Object");
+        }
+
+        @Override
+        public int getSignumCost() {
+            throw new IllegalStateException("Attempted to access property of Dummy Config Object");
+        }
+    };
+    private static CommonConfigAccess common = dummyCommon;
+    private static ClientConfigAccess client = dummyClient;
+    private static ServerConfigAccess server = dummyServer;
+
+    public static CommonConfigAccess getCommon() {
+        return common;
+    }
+
+    public static void setCommon(CommonConfigAccess common) {
+        if ({{ classname }}Config.common != dummyCommon) {
+            {{ classname }}.LOGGER.warn("CommonConfigAccess was replaced! Old {} New {}", {{ classname }}Config.common.getClass().getName(), common.getClass().getName());
+        }
+        {{ classname }}Config.common = common;
+    }
+
+    public static ClientConfigAccess getClient() {
+        return client;
+    }
+
+    public static void setClient(ClientConfigAccess client) {
+        if ({{ classname }}Config.client != dummyClient) {
+            {{ classname }}.LOGGER.warn("ClientConfigAccess was replaced! Old {} New {}", {{ classname }}Config.client.getClass().getName(), client.getClass().getName());
+        }
+        {{ classname }}Config.client = client;
+    }
+
+    public static ServerConfigAccess getServer() {
+        return server;
+    }
+
+    public static void setServer(ServerConfigAccess server) {
+
+        if ({{ classname }}Config.server != dummyServer) {
+            {{ classname }}.LOGGER.warn("ServerConfigAccess was replaced! Old {} New {}", {{ classname }}Config.server.getClass().getName(), server.getClass().getName());
+        }
+        {{ classname }}Config.server = server;
+    }
+
+    public static int bound(int toBind, int lower, int upper) {
+        return Math.min(Math.max(toBind, lower), upper);
+    }
+
+    public static double bound(double toBind, double lower, double upper) {
+        return Math.min(Math.max(toBind, lower), upper);
+    }
+
+    public interface CommonConfigAccess {
+    }
+
+    public interface ClientConfigAccess {
+    }
+
+    public interface ServerConfigAccess {
+        double DEF_MIN_COST = 0.0001;
+        double DEF_MAX_COST = 10_000.0;
+        double DEFAULT_CONGRATS_COST = 1.5;
+        double DEFAULT_SIGNUM_COST = 1.0;
+
+        int getCongratsCost();
+
+        int getSignumCost();
+    }
+}

template/{{ common_path }}/src/main/java/{{ package_path }}/{{ classname }}.java.jinja

@@ -24,6 +24,7 @@ public class {{ classname }} {
     public static void init() {
         LOGGER.info("{{ display_name }} says hello!");
 
+        {{ classname }}Abstractions.initPlatformSpecific();
         {{ classname }}ItemRegistry.init();
         {{ classname }}IotaTypeRegistry.init();
         {{ classname }}PatternRegistry.init();

template/{{ common_path }}/src/main/java/{{ package_path }}/{{ classname }}Abstractions.java.jinja

@@ -31,4 +31,9 @@ public class {{ classname }}Abstractions {
         // Just throw an error, the content should get replaced at runtime.
         throw new AssertionError();
     }
+
+    @ExpectPlatform
+    public static void initPlatformSpecific() {
+        throw new AssertionError();
+    }
 }

template/{{ fabric_path }}/src/main/java/{{ package_path }}/fabric/{{ classname }}AbstractionsImpl.java.jinja

@@ -12,4 +12,8 @@ public class {{ classname }}AbstractionsImpl {
     public static Path getConfigDirectory() {
         return FabricLoader.getInstance().getConfigDir();
     }
+
+    public static void initPlatformSpecific() {
+        {{ classname }}ConfigFabric.init();
+    }
 }

template/{{ fabric_path }}/src/main/java/{{ package_path }}/fabric/{{ classname }}ConfigFabric.java.jinja

@@ -0,0 +1,80 @@
+package {{ package }}.fabric;
+
+import at.petrak.hexcasting.api.misc.MediaConstants;
+import dev.architectury.platform.Platform;
+import {{ package }}.{{ classname }};
+import {{ package }}.api.config.{{ classname }}Config;
+import me.shedaniel.autoconfig.AutoConfig;
+import me.shedaniel.autoconfig.ConfigData;
+import me.shedaniel.autoconfig.annotation.Config;
+import me.shedaniel.autoconfig.annotation.ConfigEntry;
+import me.shedaniel.autoconfig.serializer.JanksonConfigSerializer;
+import me.shedaniel.autoconfig.serializer.PartitioningSerializer;
+import net.fabricmc.api.EnvType;
+
+@SuppressWarnings({"FieldCanBeLocal", "FieldMayBeFinal"})
+@Config(name = {{ classname }}.MOD_ID)
+public class {{ classname }}ConfigFabric extends PartitioningSerializer.GlobalData {
+    @ConfigEntry.Category("common")
+    @ConfigEntry.Gui.TransitiveObject
+    public final Common common = new Common();
+    @ConfigEntry.Category("client")
+    @ConfigEntry.Gui.TransitiveObject
+    public final Client client = new Client();
+    @ConfigEntry.Category("server")
+    @ConfigEntry.Gui.TransitiveObject
+    public final Server server = new Server();
+
+    public static void init() {
+        AutoConfig.register({{ classname }}ConfigFabric.class, PartitioningSerializer.wrap(JanksonConfigSerializer::new));
+        var instance = AutoConfig.getConfigHolder({{ classname }}ConfigFabric.class).getConfig();
+
+        {{ classname }}Config.setCommon(instance.common);
+
+        if (Platform.getEnv().equals(EnvType.CLIENT)) {
+            {{ classname }}Config.setClient(instance.client);
+        }
+
+        // Needed for logical server in singleplayer, do not access server configs from client code
+        {{ classname }}Config.setServer(instance.server);
+    }
+
+
+    @Config(name = "common")
+    private static class Common implements ConfigData, {{ classname }}Config.CommonConfigAccess {
+    }
+
+    @Config(name = "client")
+    private static class Client implements ConfigData, {{ classname }}Config.ClientConfigAccess {
+    }
+
+
+    @Config(name = "server")
+    private static class Server implements ConfigData, {{ classname }}Config.ServerConfigAccess {
+
+        @ConfigEntry.Gui.CollapsibleObject
+        private Costs costs = new Costs();
+
+        @Override
+        public void validatePostLoad() throws ValidationException {
+            this.costs.signumCost = {{ classname }}Config.bound(this.costs.signumCost, DEF_MIN_COST, DEF_MAX_COST);
+            this.costs.congratsCost = {{ classname }}Config.bound(this.costs.congratsCost, DEF_MIN_COST, DEF_MAX_COST);
+        }
+
+        @Override
+        public int getSignumCost() {
+            return (int) (costs.signumCost * MediaConstants.DUST_UNIT);
+        }
+
+        @Override
+        public int getCongratsCost() {
+            return (int) (costs.congratsCost * MediaConstants.DUST_UNIT);
+        }
+
+        static class Costs {
+            // costs of actions
+            double signumCost = DEFAULT_SIGNUM_COST;
+            double congratsCost = DEFAULT_CONGRATS_COST;
+        }
+    }
+}

template/{{ forge_path }}/src/main/java/{{ package_path }}/forge/{{ classname }}AbstractionsImpl.java.jinja

@@ -12,4 +12,8 @@ public class {{ classname }}AbstractionsImpl {
     public static Path getConfigDirectory() {
         return FMLPaths.CONFIGDIR.get();
     }
+
+    public static void initPlatformSpecific() {
+        {{ classname }}ConfigForge.init();
+    }
 }

template/{{ forge_path }}/src/main/java/{{ package_path }}/forge/{{ classname }}ConfigForge.java.jinja

@@ -0,0 +1,61 @@
+package {{ package }}.forge;
+
+import at.petrak.hexcasting.api.misc.MediaConstants;
+import {{ package }}.api.config.{{ classname }}Config;
+import net.minecraftforge.common.ForgeConfigSpec;
+import net.minecraftforge.fml.ModLoadingContext;
+import net.minecraftforge.fml.config.ModConfig;
+import org.apache.commons.lang3.tuple.Pair;
+
+public class {{ classname }}ConfigForge {
+
+    public static void init() {
+        Pair<Common, ForgeConfigSpec> config = (new ForgeConfigSpec.Builder()).configure(Common::new);
+        Pair<Client, ForgeConfigSpec> clientConfig = (new ForgeConfigSpec.Builder()).configure(Client::new);
+        Pair<Server, ForgeConfigSpec> serverConfig = (new ForgeConfigSpec.Builder()).configure(Server::new);
+        {{ classname }}Config.setCommon(config.getLeft());
+        {{ classname }}Config.setClient(clientConfig.getLeft());
+        {{ classname }}Config.setServer(serverConfig.getLeft());
+        ModLoadingContext mlc = ModLoadingContext.get();
+        mlc.registerConfig(ModConfig.Type.COMMON, config.getRight());
+        mlc.registerConfig(ModConfig.Type.CLIENT, clientConfig.getRight());
+        mlc.registerConfig(ModConfig.Type.SERVER, serverConfig.getRight());
+    }
+
+    public static class Common implements {{ classname }}Config.CommonConfigAccess {
+        public Common(ForgeConfigSpec.Builder builder) {
+
+        }
+    }
+
+    public static class Client implements {{ classname }}Config.ClientConfigAccess {
+        public Client(ForgeConfigSpec.Builder builder) {
+
+        }
+    }
+
+    public static class Server implements {{ classname }}Config.ServerConfigAccess {
+        // costs of actions
+        private static ForgeConfigSpec.DoubleValue congratsCost;
+        private static ForgeConfigSpec.DoubleValue signumCost;
+
+        public Server(ForgeConfigSpec.Builder builder) {
+            builder.translation("text.autoconfig.{{ modid }}.option.server.costs").push("costs");
+
+            congratsCost = builder.translation("text.autoconfig.{{ modid }}.option.server.costs.congratsCost").defineInRange("congratsCost", DEFAULT_CONGRATS_COST, DEF_MIN_COST, DEF_MAX_COST);
+            signumCost = builder.translation("text.autoconfig.{{ modid }}.option.server.costs.signumCost").defineInRange("signumCost", DEFAULT_SIGNUM_COST, DEF_MIN_COST, DEF_MAX_COST);
+
+            builder.pop();
+        }
+
+        @Override
+        public int getCongratsCost() {
+            return (int) (congratsCost.get() * MediaConstants.DUST_UNIT);
+        }
+
+        @Override
+        public int getSignumCost() {
+            return (int) (signumCost.get() * MediaConstants.DUST_UNIT);
+        }
+    }
+}