adding a better water model

Author: RealAntEngineer

.gitignore

@@ -25,4 +25,5 @@ run
 forge*changelog.txt
 
 # personnal info
-.env
+.env
+/logs/

build.gradle

@@ -116,7 +116,9 @@ repositories {
         name = "Modrinth"
         url = "https://api.modrinth.com/maven"
     }
-
+    maven {
+        url = "https://mvnrepository.com"
+    }
     //curios
     maven {
         url = "https://maven.theillusivec4.top/"
@@ -154,7 +156,8 @@ dependencies {
     //unit test tool
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
-
+    //x chart to plot things
+    implementation("org.knowm.xchart:xchart:3.2.2")
 
 }
 mixin {
@@ -204,6 +207,7 @@ tasks.named('jar', Jar).configure {
 
 tasks.test {
     useJUnitPlatform()
+    debug = true;
 }
 // However if you are in a multi-project build, dev time needs unobfed jar files, so you can delay the obfuscation until publishing by doing:
 // tasks.named('publish').configure {

src/main/java/com/rae/formicapi/FormicApiLang.java

@@ -0,0 +1,97 @@
+package com.rae.formicapi;
+
+import com.rae.formicapi.units.Pressure;
+import com.rae.formicapi.units.RadiationFlux;
+import com.rae.formicapi.units.Temperature;
+import com.rae.formicapi.config.FormicAPIConfigs;
+import com.simibubi.create.foundation.utility.CreateLang;
+import net.createmod.catnip.lang.Lang;
+import net.createmod.catnip.lang.LangBuilder;
+import net.createmod.catnip.lang.LangNumberFormat;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraftforge.fluids.FluidStack;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FormicApiLang extends Lang {
+    //blatant copy of CreateLang
+    /**
+     * legacy-ish. Use CROWNSLang.translate and other builder methods where possible
+     */
+    public static MutableComponent translateDirect(String key, Object... args) {
+        Object[] args1 = LangBuilder.resolveBuilders(args);
+        return Component.translatable(FormicAPI.MODID + "." + key, args1);
+    }
+
+    public static List<Component> translatedOptions(String prefix, String... keys) {
+        List<Component> result = new ArrayList<>(keys.length);
+        for (String key : keys)
+            result.add(translate((prefix != null ? prefix + "." : "") + key).component());
+        return result;
+    }
+
+//
+
+    public static LangBuilder builder() {
+        return new LangBuilder(FormicAPI.MODID);
+    }
+
+    public static LangBuilder blockName(BlockState state) {
+        return builder().add(state.getBlock()
+                .getName());
+    }
+
+    public static LangBuilder itemName(ItemStack stack) {
+        return builder().add(stack.getHoverName()
+                .copy());
+    }
+
+    public static LangBuilder fluidName(FluidStack stack) {
+        return builder().add(stack.getDisplayName()
+                .copy());
+    }
+
+    public static LangBuilder number(double d) {
+        return builder().text(LangNumberFormat.format(d));
+    }
+
+    public static LangBuilder translate(String langKey, Object... args) {
+        return builder().translate(langKey, args);
+    }
+
+    public static LangBuilder text(String text) {
+        return builder().text(text);
+    }
+
+    @Deprecated // Use while implementing and replace all references with Lang.translate
+    public static LangBuilder temporaryText(String text) {
+        return builder().text(text);
+    }
+
+    public static LangBuilder formatTemperature(float temperature) {
+        Temperature unit = FormicAPIConfigs.CLIENT.units.temperature.get();
+        return CreateLang.builder().add(Component.literal("T = "))
+                .add(number(unit.convert(temperature)))
+                .text(" ")
+                .add(unit.getSymbol());
+    }
+    public static LangBuilder formatPressure(float pressure) {
+        Pressure unit = FormicAPIConfigs.CLIENT.units.pressure.get();
+        return CreateLang.builder().add(Component.literal("P = "))
+                .add(number(unit.convert(pressure)))
+                .text(" ")
+                .add(unit.getSymbol());
+    }
+    public static LangBuilder formatRadiationFlux(float radiationFlux) {
+        RadiationFlux unit = FormicAPIConfigs.CLIENT.units.radiationFlux.get();
+        return CreateLang.builder().add(Component.literal("activity : "))
+                .add(number(unit.convert(radiationFlux)))
+                .text(" ")
+                .add(unit.getSymbol());
+    }
+
+}

src/main/java/com/rae/formicapi/config/CROWNSUnits.java

@@ -0,0 +1,25 @@
+package com.rae.formicapi.config;
+
+import com.rae.formicapi.units.Pressure;
+import com.rae.formicapi.units.RadiationFlux;
+import com.rae.formicapi.units.Temperature;
+import net.createmod.catnip.config.ConfigBase;
+
+public class CROWNSUnits extends ConfigBase {
+    public final ConfigEnum<Temperature> temperature = e(Temperature.CELSIUS,"temperature", Comments.temperature);
+    public final ConfigEnum<Pressure> pressure = e(Pressure.ATMOSPHERES,"pressure", Comments.pressure);
+    public final ConfigEnum<RadiationFlux> radiationFlux = e(RadiationFlux.MEGA_BECQUERELS,"radiation_flux", Comments.radiationFlux);
+
+
+    @Override
+    public String getName() {
+        return "units";
+    }
+    private static class Comments {
+        static String temperature ="unit used for temperature";
+        static String pressure ="unit used for pressure";
+        static String radiationFlux ="unit used for radiation activity";
+
+
+    }
+}

src/main/java/com/rae/formicapi/config/FormicAPICfgClient.java

@@ -0,0 +1,24 @@
+package com.rae.formicapi.config;
+
+
+import com.rae.formicapi.FormicAPI;
+import net.createmod.catnip.config.ConfigBase;
+import org.jetbrains.annotations.NotNull;
+
+public class FormicAPICfgClient extends ConfigBase {
+
+
+    public final CROWNSUnits units = nested(0, CROWNSUnits::new, Comments.units);
+    @Override
+    public @NotNull String getName() {
+        return FormicAPI.MODID +".client";
+    }
+
+    private static class Comments {
+        static String units = "Units used";
+        static String nuclear = "Graphic config for nuclear";
+        static String nuclearParticle = "Radiation Particles";
+
+    }
+
+}

src/main/java/com/rae/formicapi/config/FormicAPIConfigs.java

@@ -0,0 +1,70 @@
+package com.rae.formicapi.config;
+
+import net.createmod.catnip.config.ConfigBase;
+import net.minecraftforge.common.ForgeConfigSpec;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.ModLoadingContext;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.config.ModConfig;
+import net.minecraftforge.fml.event.config.ModConfigEvent;
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.EnumMap;
+import java.util.Map;
+import java.util.function.Supplier;
+
+// An example config class. This is not required, but it's a good idea to have one to keep your config organized.
+// Demonstrates how to use Forge's config APIs
+@Mod.EventBusSubscriber(bus = Mod.EventBusSubscriber.Bus.MOD)
+
+public class FormicAPIConfigs
+{
+    private static final Map<ModConfig.Type, ConfigBase> CONFIGS = new EnumMap<>(ModConfig.Type.class);
+
+    public static FormicAPICfgClient CLIENT;
+
+    public FormicAPIConfigs() {
+    }
+
+    public static ConfigBase byType(ModConfig.Type type) {
+        return CONFIGS.get(type);
+    }
+
+    private static <T extends ConfigBase> T register(Supplier<T> factory, ModConfig.Type side) {
+        Pair<T, ForgeConfigSpec> specPair = new ForgeConfigSpec.Builder().configure((builder) -> {
+            T config = factory.get();
+            config.registerAll(builder);
+            return config;
+        });
+        T config = specPair.getLeft();
+        config.specification = specPair.getRight();
+        CONFIGS.put(side, config);
+        return config;
+    }
+
+    public static void registerConfigs(ModLoadingContext context) {
+        CLIENT = register(FormicAPICfgClient::new, ModConfig.Type.CLIENT);
+        //COMMON = register(CSCfgCommon::new, ModConfig.Type.COMMON);
+
+        for (Map.Entry<ModConfig.Type, ConfigBase> pair : CONFIGS.entrySet())
+            context.registerConfig(pair.getKey(), pair.getValue().specification);
+
+        //BlockStressValues.registerProvider(context.getActiveNamespace(), SERVER.kinetics.stressValues);
+    }
+
+    @SubscribeEvent
+    public static void onLoad(ModConfigEvent.Loading event) {
+        for (ConfigBase config : CONFIGS.values())
+            if (config.specification == event.getConfig()
+                    .getSpec())
+                config.onLoad();
+    }
+
+    @SubscribeEvent
+    public static void onReload(ModConfigEvent.Reloading event) {
+        for (ConfigBase config : CONFIGS.values())
+            if (config.specification == event.getConfig()
+                    .getSpec())
+                config.onReload();
+    }
+}