initial commit

src/main/java/draylar/omegaconfig/OmegaConfig.java

@@ -0,0 +1,212 @@
+package draylar.omegaconfig;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import draylar.omegaconfig.api.Comment;
+import draylar.omegaconfig.api.Config;
+import draylar.omegaconfig.api.SyncableExclusionStrategy;
+import draylar.omegaconfig.exception.NoValidConstructorException;
+import io.netty.buffer.Unpooled;
+import net.fabricmc.api.ModInitializer;
+import net.fabricmc.fabric.api.network.ServerSidePacketRegistry;
+import net.fabricmc.fabric.api.networking.v1.ServerLoginNetworking;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.network.PacketByteBuf;
+import net.minecraft.util.Identifier;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.*;
+
+public class OmegaConfig implements ModInitializer {
+
+    private static final Logger LOGGER = LogManager.getLogger();
+    private static final List<Config> REGISTERED_CONFIGURATIONS = new ArrayList<>();
+    public static final Gson GSON = new GsonBuilder().setPrettyPrinting().create();
+
+    public static final Identifier CONFIG_SYNC_PACKET = new Identifier("omegaconfig", "sync");
+    public static final Gson SYNC_ONLY_GSON = new GsonBuilder().addSerializationExclusionStrategy(new SyncableExclusionStrategy()).setPrettyPrinting().create();
+
+    @Override
+    public void onInitialize() {
+        ServerPlayConnectionEvents.JOIN.register((handler, sender, server) -> {
+            server.execute(() -> {
+                PacketByteBuf packet = new PacketByteBuf(Unpooled.buffer());
+
+                // list of configurations that are synced
+                CompoundTag root = new CompoundTag();
+                ListTag configurations = new ListTag();
+
+                // Iterate over each configuration.
+                // Find values that should be synced and send the value over.
+                OmegaConfig.getRegisteredConfigurations().forEach(config -> {
+                    if(config.hasAnySyncable()) {
+                        configurations.add(config.writeSyncingTag());
+                    }
+                });
+
+                // save to packet and send to user
+                root.put("Configurations", configurations);
+                packet.writeCompoundTag(root);
+                handler.sendPacket(ServerPlayNetworking.createS2CPacket(CONFIG_SYNC_PACKET, packet));
+            });
+        });
+    }
+
+    public static <T extends Config> T register(Class<T> configClass) {
+        try {
+            // Attempt to instantiate a new instance of this class.
+            T config = configClass.getDeclaredConstructor().newInstance();
+
+            // Exceptions will have been thrown at this point.
+            // We want to provide access to the config as soon as it is created, so we:
+            //    1. serialize to disk if the config does not already exist
+            //    2. read from disk if it does exist
+            if(!configExists(config)) {
+                writeConfig(configClass, config);
+                REGISTERED_CONFIGURATIONS.add(config);
+            } else {
+                try {
+                    // Read from the disk config file to populate the correct values into our config object.
+                    List<String> lines = Files.readAllLines(getConfigPath(config));
+                    lines.removeIf(line -> line.trim().startsWith("//"));
+                    StringBuilder res = new StringBuilder();
+                    lines.forEach(res::append);
+                    T object = GSON.fromJson(res.toString(), configClass);
+
+                    // re-write the config to add new values
+                    writeConfig(configClass, object);
+                    REGISTERED_CONFIGURATIONS.add(object);
+                    return object;
+                } catch (IOException ioException) {
+                    LOGGER.error(ioException);
+                    LOGGER.info(String.format("Read error, using default values for config %s.", configClass.toString()));
+                }
+            }
+
+            return config;
+        } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException exception) {
+            throw new NoValidConstructorException();
+        }
+    }
+
+    private static  <T extends Config> void  writeConfig(Class<T> configClass, T instance) {
+        // Write the config to disk with the default values.
+        String json = GSON.toJson(instance);
+
+        // Cursed time.
+        List<String> lines = new ArrayList<>(Arrays.asList(json.split("\n")));
+        Map<Integer, String> insertions = new HashMap<>();
+        Map<String, String> keyToComments = new HashMap<>();
+
+        // populate key -> comments map
+        for(Field field : configClass.getDeclaredFields()) {
+            addFieldComments(field, keyToComments);
+        }
+
+        // get inner-class fields
+        // TODO: recursively get inner classes?
+        for(Class<?> innerClass : configClass.getDeclaredClasses()) {
+            for(Field field : innerClass.getDeclaredFields()) {
+                addFieldComments(field, keyToComments);
+            }
+        }
+
+        // Find areas we should insert comments into...
+        for (int i = 0; i < lines.size(); i++) {
+            String at = lines.get(i);
+
+            // Check if we should insert comment
+            for (Map.Entry<String, String> entry : keyToComments.entrySet()) {
+                String key = entry.getKey();
+                String comment = entry.getValue();
+
+                if (at.trim().startsWith(String.format("\"%s\"", key))) {
+                    insertions.put(i + insertions.size(), String.format("%s//%s", getStartingWhitespace(at), comment));
+                    break;
+                }
+            }
+        }
+
+        // insertions -> list
+        insertions.forEach(lines::add);
+
+        // list -> string
+        StringBuilder res = new StringBuilder();
+        lines.forEach(str -> res.append(String.format("%s%n", str)));
+
+        try {
+            Files.write(getConfigPath(instance), res.toString().getBytes());
+        } catch (IOException ioException) {
+            LOGGER.error(ioException);
+            LOGGER.info(String.format("Write error, using default values for config %s.", configClass.toString()));
+        }
+    }
+
+    private static void addFieldComments(Field field, Map<String, String> keyToComments) {
+        String fieldName = field.getName();
+        Annotation[] annotations = field.getDeclaredAnnotations();
+
+        // Find comment
+        for (Annotation annotation : annotations) {
+            if(annotation instanceof Comment) {
+                keyToComments.put(fieldName, ((Comment) annotation).value());
+                break;
+            }
+        }
+    }
+
+    /**
+     * Returns a string with the left-side whitespace characters of the given input, up till the first non-whitespace character.
+     *
+     * <p>
+     * "   hello" -> "   "
+     * "p" -> ""
+     * " p" -> " "
+     *
+     * @param input  input to retrieve whitespaces from
+     * @return       starting whitespaces from the given input
+     */
+    private static String getStartingWhitespace(String input) {
+        int index = -1;
+
+        char[] chars = input.toCharArray();
+        for(int i = 0; i < chars.length; i++) {
+            char at = chars[i];
+
+            if(at != ' ') {
+                index = i;
+                break;
+            }
+        }
+
+        if(index != -1) {
+            return input.substring(0, index);
+        } else {
+            return "";
+        }
+    }
+
+    public static Path getConfigPath(Config config) {
+        return Paths.get(FabricLoader.getInstance().getConfigDir().toString(), String.format("%s.json", config.getFileName()));
+    }
+
+    public static boolean configExists(Config config) {
+        return Files.exists(getConfigPath(config));
+    }
+
+    public static List<Config> getRegisteredConfigurations() {
+        return REGISTERED_CONFIGURATIONS;
+    }
+}

src/main/java/draylar/omegaconfig/OmegaConfigClient.java

@@ -0,0 +1,29 @@
+package draylar.omegaconfig;
+
+import draylar.omegaconfig.api.Config;
+import draylar.omegaconfig.api.screen.ModMenuHelper;
+import draylar.omegaconfig.api.screen.OmegaConfigScreen;
+import draylar.omegaconfig.api.screen.OmegaConfigScreenSupplier;
+import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.fabricmc.loader.api.FabricLoader;
+
+@Environment(EnvType.CLIENT)
+public class OmegaConfigClient implements ClientModInitializer {
+
+    @Override
+    public void onInitializeClient() {
+
+    }
+
+    public static <T extends Config> void registerConfigScreen(T config) {
+        registerConfigScreen(config, parent -> new OmegaConfigScreen<>(config, parent));
+    }
+
+    public static <T extends Config> void registerConfigScreen(T config, OmegaConfigScreenSupplier<T> screenFactory) {
+        if(FabricLoader.getInstance().isModLoaded("modmenu")) {
+            ModMenuHelper.injectScreen(config, screenFactory);
+        }
+    }
+}

src/main/java/draylar/omegaconfig/api/Comment.java

@@ -0,0 +1,12 @@
+package draylar.omegaconfig.api;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface Comment {
+    String value() default "";
+}

src/main/java/draylar/omegaconfig/api/Config.java

@@ -0,0 +1,66 @@
+package draylar.omegaconfig.api;
+
+import draylar.omegaconfig.OmegaConfig;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.StringTag;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Arrays;
+
+public interface Config {
+
+    /**
+     * Writes this configuration file instance to disk.
+     * Useful for saving modified values during runtime.
+     */
+    default void save() {
+
+    }
+
+    /**
+     * @return  an instance of this Config class with all default values.
+     */
+    default Config getDefault() {
+        return null;
+    }
+
+    default CompoundTag writeSyncingTag() {
+        CompoundTag tag = new CompoundTag();
+        tag.putString("ConfigName", getFileName());
+
+        // all config vs. individual fields
+        if(Arrays.stream(getClass().getAnnotations()).anyMatch(annotation -> annotation instanceof Syncing)) {
+            // write ALL fields to tag
+            String json = OmegaConfig.GSON.toJson(this);
+            tag.putString("Serialized", json);
+            tag.putBoolean("AllSync", true);
+        } else {
+            // write all syncable fields to tag
+            String json = OmegaConfig.SYNC_ONLY_GSON.toJson(this);
+            tag.putString("Serialized", json);
+            tag.putBoolean("AllSync", false);
+        }
+
+        return tag;
+    }
+
+    /**
+     * @return  true if this {@link Config} has any values that should be synced to the client
+     */
+    default boolean hasAnySyncable() {
+        boolean hasSyncingField = Arrays.stream(getClass().getDeclaredFields()).anyMatch(field -> Arrays.stream(field.getDeclaredAnnotations()).anyMatch(annotation -> annotation instanceof Syncing));
+        boolean classSyncs = Arrays.stream(getClass().getDeclaredAnnotations()).anyMatch(annotation -> annotation instanceof Syncing);
+        return hasSyncingField | classSyncs;
+    }
+
+    String getFileName();
+
+    @Nullable
+    default String getModid() {
+        return null;
+    }
+
+    default boolean hasMenu() {
+        return true;
+    }
+}

src/main/java/draylar/omegaconfig/api/SyncableExclusionStrategy.java

@@ -0,0 +1,17 @@
+package draylar.omegaconfig.api;
+
+import com.google.gson.ExclusionStrategy;
+import com.google.gson.FieldAttributes;
+
+public class SyncableExclusionStrategy implements ExclusionStrategy {
+
+    @Override
+    public boolean shouldSkipField(FieldAttributes f) {
+        return f.getAnnotations().stream().noneMatch(annotation -> annotation instanceof Syncing);
+    }
+
+    @Override
+    public boolean shouldSkipClass(Class<?> clazz) {
+        return false;
+    }
+}

src/main/java/draylar/omegaconfig/api/Syncing.java

@@ -0,0 +1,11 @@
+package draylar.omegaconfig.api;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD, ElementType.TYPE})
+public @interface Syncing {
+}

src/main/java/draylar/omegaconfig/api/screen/ModMenuHelper.java

@@ -0,0 +1,28 @@
+package draylar.omegaconfig.api.screen;
+
+import com.google.common.collect.ImmutableMap;
+import com.terraformersmc.modmenu.api.ConfigScreenFactory;
+import draylar.omegaconfig.api.Config;
+import draylar.omegaconfig.mixin.ModMenuAccessor;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@Environment(EnvType.CLIENT)
+public class ModMenuHelper {
+
+    public static <T extends Config> void injectScreen(T config, OmegaConfigScreenSupplier<T> factory) {
+        // collect existing configurations
+        ImmutableMap<String, ConfigScreenFactory<?>> configScreenFactories = ModMenuAccessor.getConfigScreenFactories();
+        Map<String, ConfigScreenFactory<?>> nMap = new HashMap<>();
+        nMap.putAll(configScreenFactories);
+
+        // add our factory
+        nMap.put(config.getModid(), factory::get);
+
+        // they will suspect nothing
+        ModMenuAccessor.setConfigScreenFactories(ImmutableMap.copyOf(nMap));
+    }
+}

src/main/java/draylar/omegaconfig/api/screen/OmegaConfigScreen.java

@@ -0,0 +1,119 @@
+package draylar.omegaconfig.api.screen;
+
+import draylar.omegaconfig.api.Config;
+import draylar.omegaconfig.api.screen.widget.LabelWidget;
+import draylar.omegaconfig.api.screen.widget.TypeWidgets;
+import draylar.omegaconfig.api.screen.widget.WidgetSupplier;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.Drawable;
+import net.minecraft.client.gui.Element;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.widget.AbstractButtonWidget;
+import net.minecraft.client.gui.widget.ButtonWidget;
+import net.minecraft.client.gui.widget.TextFieldWidget;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.text.LiteralText;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.Pair;
+
+import java.lang.reflect.Field;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class OmegaConfigScreen<T extends Config> extends Screen {
+
+    private static final List<Class<?>> validClasses = Arrays.asList(Double.class, String.class, Boolean.class);
+    private final T config;
+    private final Screen parent;
+    private final Map<Field, Pair<WidgetSupplier<Object, AbstractButtonWidget>, AbstractButtonWidget>> fieldWidgets = new HashMap<>();
+
+    public OmegaConfigScreen(T config, Screen parent) {
+        super(new LiteralText(""));
+        this.config = config;
+        this.parent = parent;
+    }
+
+    @Override
+    public void init() {
+        super.init();
+
+        try {
+            // add label & button for each config entry
+            // TODO: SUB-CLASS SUPPORT
+            List<Field> collect = Arrays.stream(config.getClass().getDeclaredFields()).filter(field -> validClasses.contains(TypeWidgets.unbox(field.getType()))).collect(Collectors.toList());
+            int over = 0;
+
+            for (Field field : collect) {
+                Class<?> unbox = TypeWidgets.unbox(field.getType());
+
+                // label
+                addChild(new LabelWidget(150, 5 + 20 * over, new LiteralText(field.getName())));
+
+                // get value
+                field.setAccessible(true);
+                Object value = field.get(config);
+
+                // button / interact
+                AbstractButtonWidget button;
+                WidgetSupplier<Object, AbstractButtonWidget> widgetSupplier = (WidgetSupplier<Object, AbstractButtonWidget>) TypeWidgets.get(unbox);
+                if(widgetSupplier != null) {
+                    button = widgetSupplier.create(250, 5 + 20 * over, 50, 50, new LiteralText(field.getName()), value);
+                } else {
+                    button = new TextFieldWidget(client.textRenderer, 250, 5 + 20 * over, 50, 20, new LiteralText(field.getName()));
+                }
+
+                fieldWidgets.put(field, new Pair<>(widgetSupplier, button));
+
+                addButton(button);
+
+                over++;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        // save and exit
+        ButtonWidget exit = new ButtonWidget(width - 60, height - 30, 50, 20, new LiteralText("Exit"), widget -> onClose());
+        ButtonWidget save = new ButtonWidget(10, height - 30, 50, 20, new LiteralText("Save"), widget -> {
+            fieldWidgets.forEach((field, pair) -> {
+                try {
+                    field.set(config, pair.getLeft().get(pair.getRight()));
+                } catch (IllegalAccessException e) {
+                    e.printStackTrace();
+                }
+            });
+
+            config.save();
+        });
+        addButton(save);
+        addButton(exit);
+    }
+
+    @Override
+    public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) {
+        renderBackground(matrices);
+
+        for (AbstractButtonWidget button : this.buttons) {
+            button.render(matrices, mouseX, mouseY, delta);
+        }
+
+        for (Element element : this.children) {
+            if (element instanceof Drawable && !buttons.contains(element)) {
+                ((Drawable) element).render(matrices, mouseX, mouseY, delta);
+            }
+        }
+    }
+
+    @Override
+    public void onClose() {
+        client.openScreen(parent);
+    }
+
+    @Override
+    public void renderBackground(MatrixStack matrices) {
+        super.renderBackground(matrices);
+
+        MinecraftClient.getInstance().getTextureManager().bindTexture(new Identifier("textures/block/dirt.png"));
+        drawTexture(matrices, 0, 0, 0, 0, 16, 16);
+    }
+}

src/main/java/draylar/omegaconfig/api/screen/OmegaConfigScreenSupplier.java

@@ -0,0 +1,8 @@
+package draylar.omegaconfig.api.screen;
+
+import draylar.omegaconfig.api.Config;
+import net.minecraft.client.gui.screen.Screen;
+
+public interface OmegaConfigScreenSupplier<T extends Config> {
+    OmegaConfigScreen<T> get(Screen parent);
+}

src/main/java/draylar/omegaconfig/api/screen/widget/LabelWidget.java

@@ -0,0 +1,26 @@
+package draylar.omegaconfig.api.screen.widget;
+
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.Drawable;
+import net.minecraft.client.gui.DrawableHelper;
+import net.minecraft.client.gui.Element;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.text.Text;
+
+public class LabelWidget extends DrawableHelper implements Drawable, Element {
+
+    private final int x;
+    private final int y;
+    private final Text message;
+
+    public LabelWidget(int x, int y, Text message) {
+        this.x = x;
+        this.y = y;
+        this.message = message;
+    }
+
+    @Override
+    public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) {
+        drawTextWithShadow(matrices, MinecraftClient.getInstance().textRenderer, message, x, y, 0xffffff);
+    }
+}

src/main/java/draylar/omegaconfig/api/screen/widget/TypeWidgets.java

@@ -0,0 +1,45 @@
+package draylar.omegaconfig.api.screen.widget;
+
+import draylar.omegaconfig.api.screen.widget.supplier.BooleanWidgetSupplier;
+import draylar.omegaconfig.api.screen.widget.supplier.DoubleWidgetSupplier;
+import draylar.omegaconfig.api.screen.widget.supplier.StringWidgetSupplier;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class TypeWidgets {
+
+    public static final Map<Class<?>, WidgetSupplier<?, ?>> CLASS_WIDGETS = new HashMap<>();
+    public static final Map<Class<?>, Class<?>> PRIMITIVE_TO_BOXED = new HashMap<>();
+
+    static {
+        CLASS_WIDGETS.put(Double.class, new DoubleWidgetSupplier());
+        CLASS_WIDGETS.put(Boolean.class, new BooleanWidgetSupplier());
+        CLASS_WIDGETS.put(String.class, new StringWidgetSupplier());
+
+        // primitive -> boxed
+        PRIMITIVE_TO_BOXED.put(boolean.class, Boolean.class);
+        PRIMITIVE_TO_BOXED.put(byte.class, Byte.class);
+        PRIMITIVE_TO_BOXED.put(char.class, Character.class);
+        PRIMITIVE_TO_BOXED.put(double.class, Double.class);
+        PRIMITIVE_TO_BOXED.put(float.class, Float.class);
+        PRIMITIVE_TO_BOXED.put(int.class, Integer.class);
+        PRIMITIVE_TO_BOXED.put(long.class, Long.class);
+        PRIMITIVE_TO_BOXED.put(short.class, Short.class);
+        PRIMITIVE_TO_BOXED.put(void.class, Void.class);
+    }
+
+    @Nullable
+    public static <T> WidgetSupplier<T, ?> get(Class<T> typeClass) {
+        return (WidgetSupplier<T, ?>) CLASS_WIDGETS.get(unbox(typeClass));
+    }
+
+    public static Class<?> unbox(Class<?> c) {
+        return PRIMITIVE_TO_BOXED.getOrDefault(c, c);
+    }
+
+    private TypeWidgets() {
+        // NO-OP
+    }
+}

src/main/java/draylar/omegaconfig/api/screen/widget/WidgetSupplier.java

@@ -0,0 +1,9 @@
+package draylar.omegaconfig.api.screen.widget;
+
+import net.minecraft.client.gui.widget.AbstractButtonWidget;
+import net.minecraft.text.LiteralText;
+
+public interface WidgetSupplier<T, A extends AbstractButtonWidget> {
+    AbstractButtonWidget create(int x, int y, int width, int height, LiteralText prompt, T value);
+    T get(A widget);
+}

src/main/java/draylar/omegaconfig/api/screen/widget/supplier/BooleanWidgetSupplier.java

@@ -0,0 +1,18 @@
+package draylar.omegaconfig.api.screen.widget.supplier;
+
+import draylar.omegaconfig.api.screen.widget.WidgetSupplier;
+import net.minecraft.client.gui.widget.CheckboxWidget;
+import net.minecraft.text.LiteralText;
+
+public class BooleanWidgetSupplier implements WidgetSupplier<Boolean, CheckboxWidget> {
+
+    @Override
+    public CheckboxWidget create(int x, int y, int width, int height, LiteralText prompt, Boolean value) {
+        return new CheckboxWidget(x, y, 20, 20, new LiteralText(""), value);
+    }
+
+    @Override
+    public Boolean get(CheckboxWidget widget) {
+        return widget.isChecked();
+    }
+}

src/main/java/draylar/omegaconfig/api/screen/widget/supplier/DoubleWidgetSupplier.java

@@ -0,0 +1,20 @@
+package draylar.omegaconfig.api.screen.widget.supplier;
+
+import draylar.omegaconfig.api.screen.widget.WidgetSupplier;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.widget.AbstractButtonWidget;
+import net.minecraft.client.gui.widget.TextFieldWidget;
+import net.minecraft.text.LiteralText;
+
+public class DoubleWidgetSupplier implements WidgetSupplier<Double, AbstractButtonWidget> {
+
+    @Override
+    public AbstractButtonWidget create(int x, int y, int width, int height, LiteralText prompt, Double value) {
+        return new TextFieldWidget(MinecraftClient.getInstance().textRenderer, x, y, width, height, new LiteralText(String.valueOf(value)));
+    }
+
+    @Override
+    public Double get(AbstractButtonWidget widget) {
+        return Double.parseDouble(widget.getMessage().asString());
+    }
+}

src/main/java/draylar/omegaconfig/api/screen/widget/supplier/StringWidgetSupplier.java

@@ -0,0 +1,20 @@
+package draylar.omegaconfig.api.screen.widget.supplier;
+
+import draylar.omegaconfig.api.screen.widget.WidgetSupplier;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.widget.AbstractButtonWidget;
+import net.minecraft.client.gui.widget.TextFieldWidget;
+import net.minecraft.text.LiteralText;
+
+public class StringWidgetSupplier implements WidgetSupplier<String, AbstractButtonWidget> {
+
+    @Override
+    public AbstractButtonWidget create(int x, int y, int width, int height, LiteralText prompt, String value) {
+        return new TextFieldWidget(MinecraftClient.getInstance().textRenderer, x, y, width, height, new LiteralText(value));
+    }
+
+    @Override
+    public String get(AbstractButtonWidget widget) {
+        return widget.getMessage().asString();
+    }
+}

src/main/java/draylar/omegaconfig/exception/NoValidConstructorException.java

@@ -0,0 +1,5 @@
+package draylar.omegaconfig.exception;
+
+public class NoValidConstructorException extends RuntimeException {
+
+}

src/main/java/draylar/omegaconfig/mixin/ClientMixin.java

@@ -0,0 +1,107 @@
+package draylar.omegaconfig.mixin;
+
+import draylar.omegaconfig.OmegaConfig;
+import draylar.omegaconfig.api.Config;
+import draylar.omegaconfig.api.Syncing;
+import net.fabricmc.fabric.api.network.ClientSidePacketRegistry;
+import net.fabricmc.fabric.api.util.NbtType;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.RunArgs;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import org.jetbrains.annotations.Nullable;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Mixin(MinecraftClient.class)
+public class ClientMixin {
+
+    @Unique
+    private final List<Config> savedClientConfig = new ArrayList<>(); // stored config from before sync is applied
+
+    @Inject(
+            method = "<init>",
+        at = @At("RETURN"))
+    private void onReturn(RunArgs args, CallbackInfo ci) {
+        ClientSidePacketRegistry.INSTANCE.register(OmegaConfig.CONFIG_SYNC_PACKET, (context, buffer) -> {
+            CompoundTag tag = buffer.readCompoundTag();
+            savedClientConfig.clear();
+
+            context.getTaskQueue().execute(() -> {
+                if(tag != null && tag.contains("Configurations")) {
+                    ListTag list = tag.getList("Configurations", NbtType.COMPOUND);
+                    list.forEach(compound -> {
+                        CompoundTag syncedConfiguration = (CompoundTag) compound;
+                        String name = syncedConfiguration.getString("ConfigName");
+                        String json = syncedConfiguration.getString("Serialized");
+                        boolean allSync = syncedConfiguration.getBoolean("AllSync");
+
+                        // find configuration class by name
+                        for (Config config : OmegaConfig.getRegisteredConfigurations()) {
+                            if (config.getFileName().equals(name)) {
+                                // bring values from server to object
+                                Config server = OmegaConfig.GSON.fromJson(json, config.getClass());
+
+                                // deep-copy original config & save it for a restore later
+                                Config cachedClient = OmegaConfig.GSON.fromJson(OmegaConfig.GSON.toJson(config), config.getClass());
+                                savedClientConfig.add(cachedClient);
+
+                                // locate all fields that differ between the client and server, assign values from server to client (this will mutate the stored object)
+                                for (Field field : server.getClass().getDeclaredFields()) {
+                                    if(allSync || Arrays.stream(field.getAnnotations()).anyMatch(annotation -> annotation instanceof Syncing)) {
+                                        try {
+                                            field.setAccessible(true);
+                                            Object serverValue = field.get(server);
+                                            field.set(config, serverValue);
+                                        } catch (IllegalAccessException e) {
+                                            e.printStackTrace();
+                                        }
+                                    }
+                                }
+
+                                break;
+                            }
+                        }
+                    });
+                }
+            });
+        });
+    }
+
+    @Inject(
+            method = "disconnect(Lnet/minecraft/client/gui/screen/Screen;)V",
+            at = @At("RETURN"))
+    private void restoreConfigurations(Screen screen, CallbackInfo ci) {
+        for(Config config : savedClientConfig) {
+            for(Config potentiallySynced : OmegaConfig.getRegisteredConfigurations()) {
+                if(config.getFileName().equals(potentiallySynced.getFileName())) {
+                    boolean allConfigSyncs = Arrays.stream(config.getClass().getAnnotations()).anyMatch(annotation -> annotation instanceof Syncing);
+
+                    // mutate object in registered configurations
+                    for (Field field : config.getClass().getDeclaredFields()) {
+                        if(allConfigSyncs || Arrays.stream(field.getAnnotations()).anyMatch(annotation -> annotation instanceof Syncing)) {
+                            try {
+                                field.setAccessible(true);
+                                Object preSyncValue = field.get(config);
+                                field.set(potentiallySynced, preSyncValue);
+                            } catch (IllegalAccessException e) {
+                                e.printStackTrace();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        savedClientConfig.clear();
+    }
+}

src/main/java/draylar/omegaconfig/mixin/ModMenuAccessor.java

@@ -0,0 +1,20 @@
+package draylar.omegaconfig.mixin;
+
+import com.google.common.collect.ImmutableMap;
+import com.terraformersmc.modmenu.ModMenu;
+import com.terraformersmc.modmenu.api.ConfigScreenFactory;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(ModMenu.class)
+public interface ModMenuAccessor {
+    @Accessor
+    static ImmutableMap<String, ConfigScreenFactory<?>> getConfigScreenFactories() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Accessor
+    static void setConfigScreenFactories(ImmutableMap<String, ConfigScreenFactory<?>> configScreenFactories) {
+        throw new UnsupportedOperationException();
+    }
+}

src/main/resources/fabric.mod.json

@@ -0,0 +1,27 @@
+{
+  "schemaVersion": 1,
+  "id": "omega-config",
+  "version": "${version}",
+  "name": "OmegaConfig",
+  "description": "The last config solution you will ever use.",
+  "authors": [
+    "Draylar"
+  ],
+  "contact": {},
+  "license": "MIT",
+  "icon": "assets/omega-config/icon.png",
+  "environment": "*",
+  "entrypoints": {
+    "main": [
+      "draylar.omegaconfig.OmegaConfig"
+    ]
+  },
+  "mixins": [
+    "omega-config.mixins.json"
+  ],
+  "depends": {
+    "fabricloader": ">=0.11.2",
+    "fabric": "*",
+    "minecraft": "1.16.5"
+  }
+}

src/main/resources/omega-config.mixins.json

@@ -0,0 +1,15 @@
+{
+  "required": true,
+  "minVersion": "0.8",
+  "package": "draylar.omegaconfig.mixin",
+  "compatibilityLevel": "JAVA_8",
+  "mixins": [
+    "ModMenuAccessor"
+  ],
+  "client": [
+    "ClientMixin"
+  ],
+  "injectors": {
+    "defaultRequire": 1
+  }
+}

src/testmod/java/draylar/omegaconfig/OmegaConfigClientTest.java

@@ -0,0 +1,19 @@
+package draylar.omegaconfig;
+
+import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.fabric.api.client.rendering.v1.HudRenderCallback;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.text.LiteralText;
+
+public class OmegaConfigClientTest implements ClientModInitializer {
+
+    @Override
+    public void onInitializeClient() {
+        OmegaConfigClient.registerConfigScreen(OmegaConfigTest.CONFIG);
+
+        HudRenderCallback.EVENT.register((stack, delta) -> {
+            MinecraftClient.getInstance().textRenderer.draw(stack, new LiteralText(String.valueOf(OmegaConfigTest.CONFIG.v)), 15, 15, 0xffffff);
+            MinecraftClient.getInstance().textRenderer.draw(stack, new LiteralText(String.valueOf(OmegaConfigTest.CONFIG.doubleTest)), 15, 30, 0xffffff);
+        });
+    }
+}

src/testmod/java/draylar/omegaconfig/OmegaConfigTest.java

@@ -0,0 +1,14 @@
+package draylar.omegaconfig;
+
+import net.fabricmc.api.ModInitializer;
+
+public class OmegaConfigTest implements ModInitializer {
+
+    public static final TestConfig CONFIG = OmegaConfig.register(TestConfig.class);
+
+    @Override
+    public void onInitialize() {
+        System.out.printf("Config value: %s%n", CONFIG.v);
+        System.out.printf("Inner class value: %s%n", CONFIG.test.innerTest);
+    }
+}

src/testmod/java/draylar/omegaconfig/TestConfig.java

@@ -0,0 +1,35 @@
+package draylar.omegaconfig;
+
+import draylar.omegaconfig.api.Comment;
+import draylar.omegaconfig.api.Config;
+import draylar.omegaconfig.api.Syncing;
+import org.jetbrains.annotations.Nullable;
+
+@Syncing
+public class TestConfig implements Config {
+
+    @Comment(value = "Hello!")
+    boolean v = false;
+
+    @Comment(value = "I'm a double.")
+    double doubleTest = 0.0;
+
+    @Comment(value = "This is an inner static class.")
+    public Test test = new Test();
+
+    public static class Test {
+
+        @Comment(value = "This is the value inside the class!")
+        public boolean innerTest = false;
+    }
+
+    @Override
+    public String getFileName() {
+        return "test-config";
+    }
+
+    @Override
+    public @Nullable String getModid() {
+        return "omega-config-test";
+    }
+}

src/testmod/resources/fabric.mod.json

@@ -0,0 +1,27 @@
+{
+  "schemaVersion": 1,
+  "id": "omega-config-test",
+  "version": "${version}",
+  "name": "OmegaConfig Test",
+  "description": "Test mod for Omega Config.",
+  "authors": [
+    "Draylar"
+  ],
+  "contact": {},
+  "license": "MIT",
+  "icon": "assets/omega-config/icon.png",
+  "environment": "*",
+  "entrypoints": {
+    "main": [
+      "draylar.omegaconfig.OmegaConfigTest"
+    ],
+    "client": [
+      "draylar.omegaconfig.OmegaConfigClientTest"
+    ]
+  },
+  "depends": {
+    "fabricloader": ">=0.11.2",
+    "fabric": "*",
+    "minecraft": "1.16.5"
+  }
+}