Make EMC be synced from server to client

1 files changed, 147 insertions, 105 deletions

diff --git a/src/main/java/lv/enes/mc/eris_alchemy/Emc.java b/src/main/java/lv/enes/mc/eris_alchemy/Emc.java
index fdc7c0a..c12b143 100644
--- a/src/main/java/lv/enes/mc/eris_alchemy/Emc.java
+++ b/src/main/java/lv/enes/mc/eris_alchemy/Emc.java
@@ -1,11 +1,18 @@
 package lv.enes.mc.eris_alchemy;
 
-import jakarta.annotation.Nonnull;
 import jakarta.annotation.Nullable;
+import lv.enes.mc.eris_alchemy.ErisAlchemyRegistry.NetworkingConstants;
+import lv.enes.mc.eris_alchemy.utils.BufUtils;
 import lv.enes.mc.eris_alchemy.utils.ItemUtils;
+import lv.enes.mc.eris_alchemy.utils.PlayerUtils;
+import net.minecraft.client.Minecraft;
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.core.registries.Registries;
+import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.tags.TagKey;
 import net.minecraft.world.item.BlockItem;
 import net.minecraft.world.item.Item;
@@ -13,86 +20,37 @@ import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.crafting.Ingredient;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.Block;
+import org.quiltmc.loader.api.minecraft.ClientOnly;
+import org.quiltmc.qsl.networking.api.PacketByteBufs;
+import org.quiltmc.qsl.networking.api.ServerPlayNetworking;
+import org.quiltmc.qsl.networking.api.client.ClientPlayNetworking;
 
 import java.text.DecimalFormat;
 import java.util.*;
 import java.util.stream.Stream;
 
-public class Emc {
+public final class Emc {
+        private Emc() {}
+
         private static final Map<ResourceLocation, OptionalDouble> ITEM_VALUES = new HashMap<>();
         private static final Map<TagKey<Item>, OptionalDouble> ITEM_TAG_VALUES = new HashMap<>();
         private static final Map<TagKey<Block>, OptionalDouble> BLOCK_TAG_VALUES = new HashMap<>();
         private static final List<SimplifiedRecipe> FAKE_RECIPES = new ArrayList<>();
 
-        private static final Map<Level, Emc> instances = Collections.synchronizedMap(new WeakHashMap<>());
+        private static final Map<ResourceLocation, OptionalDouble> VALUES = Collections.synchronizedMap(new HashMap<>());
 
-        private static final DecimalFormat formatter = new DecimalFormat("0");
+        private static final DecimalFormat FORMATTER = new DecimalFormat("0");
         static {
-                formatter.setMaximumFractionDigits(1);
+                FORMATTER.setMaximumFractionDigits(1);
         }
 
-        public static Emc getInstance(@Nonnull Level world) {
-                if (instances.containsKey(world)) {
-                        return instances.get(world);
-                }
-
-                var instance = new Emc(world);
-                instances.put(world, instance);
-                return instance;
-        }
+        private static ServerLevel overworld = null;
 
         public static String formatEmc(double value) {
-                return formatter.format(value);
+                return FORMATTER.format(value);
         }
 
-        public static void reloadData(
-                        Map<ResourceLocation, OptionalDouble> itemValues,
-                        Map<ResourceLocation, OptionalDouble> itemTagValues,
-                        Map<ResourceLocation, OptionalDouble> blockTagValues,
-                        List<SimplifiedRecipe> fakeRecipes
-        ) {
-                ITEM_VALUES.clear();
-                ITEM_VALUES.putAll(itemValues);
-
-                ITEM_TAG_VALUES.clear();
-                itemTagValues.forEach((id, value) -> ITEM_TAG_VALUES.put(TagKey.create(Registries.ITEM, id), value));
-
-                BLOCK_TAG_VALUES.clear();
-                blockTagValues.forEach((id, value) -> BLOCK_TAG_VALUES.put(TagKey.create(Registries.BLOCK, id), value));
-
-                FAKE_RECIPES.clear();
-                FAKE_RECIPES.addAll(fakeRecipes);
-
-                instances.clear();
-        }
-
-        private final Map<ResourceLocation, OptionalDouble> data;
-
-        private Emc(@Nonnull Level world) {
-                data = Collections.synchronizedMap(new HashMap<>(ITEM_VALUES));
-                ITEM_TAG_VALUES.forEach(
-                                (tag, emcValue) -> BuiltInRegistries.ITEM
-                                                .getTagOrEmpty(tag)
-                                                .forEach(holder -> data.putIfAbsent(ItemUtils.getId(holder), emcValue))
-                );
-                BLOCK_TAG_VALUES.forEach(
-                                (tag, emcValue) -> BuiltInRegistries.BLOCK
-                                                .getTagOrEmpty(tag)
-                                                .forEach(holder -> data.putIfAbsent(ItemUtils.getId(holder), emcValue))
-                );
-
-                ErisAlchemy.LOGGER.info("Calculating EMC values...");
-                var recipes = getRecipes(world);
-                var configured = new HashSet<>(data.keySet());
-                BuiltInRegistries.ITEM.keySet().forEach(item -> {
-                        configEmc(recipes, configured, item);
-                        if (!data.containsKey(item)) {
-                                ErisAlchemy.LOGGER.warn("No EMC value for '{}' known", item);
-                        }
-                });
-        }
-
-        public OptionalDouble get(ItemStack stack) {
+        public static OptionalDouble get(ItemStack stack) {
                 if (stack.isEmpty()) {
                         return OptionalDouble.empty();
                 }
@@ -118,51 +76,66 @@ public class Emc {
                                 .findFirst();
         }
 
-        public OptionalDouble get(ResourceLocation itemId) {
-                return data.getOrDefault(itemId, OptionalDouble.empty());
+        public static OptionalDouble get(ResourceLocation itemId) {
+                return VALUES.getOrDefault(itemId, OptionalDouble.empty());
         }
 
-        private List<SimplifiedRecipe> getRecipes(@Nullable Level world) {
-                Stream<SimplifiedRecipe> recipes = FAKE_RECIPES.stream();
+        @ClientOnly
+        public static void initClient(Minecraft ignoredClient) {
+                ClientPlayNetworking.registerGlobalReceiver(
+                                NetworkingConstants.UPDATE_EMCS,
+                                (client1, handler, buf, responseSender) -> {
+                                        var map = buf.readMap(FriendlyByteBuf::readResourceLocation, BufUtils::readOptionalDouble);
+                                        VALUES.clear();
+                                        VALUES.putAll(map);
+                                }
+                );
+        }
 
-                if (world != null) {
-                        recipes = Stream.concat(
-                                        recipes,
-                                        world.getRecipeManager()
-                                                        .getRecipes()
-                                                        .stream()
-                                                        .map(recipe -> new SimplifiedRecipe(recipe, world.registryAccess()))
-                        );
-                }
+        public static void initServer(MinecraftServer server) {
+                overworld = server.overworld();
+                reinit();
+                warnOfMissingValues();
+        }
 
-                return recipes.toList();
+        public static void reloadData(
+                        Map<ResourceLocation, OptionalDouble> itemValues,
+                        Map<ResourceLocation, OptionalDouble> itemTagValues,
+                        Map<ResourceLocation, OptionalDouble> blockTagValues,
+                        List<SimplifiedRecipe> fakeRecipes
+        ) {
+                ITEM_VALUES.clear();
+                ITEM_VALUES.putAll(itemValues);
+
+                ITEM_TAG_VALUES.clear();
+                itemTagValues.forEach((id, value) -> ITEM_TAG_VALUES.put(TagKey.create(Registries.ITEM, id), value));
+
+                BLOCK_TAG_VALUES.clear();
+                blockTagValues.forEach((id, value) -> BLOCK_TAG_VALUES.put(TagKey.create(Registries.BLOCK, id), value));
+
+                FAKE_RECIPES.clear();
+                FAKE_RECIPES.addAll(fakeRecipes);
+
+                reinit();
+                warnOfMissingValues();
         }
 
-        private OptionalDouble configEmc(
+        private static OptionalDouble calculateEmcForIngredient(
                         List<SimplifiedRecipe> recipes,
                         Set<ResourceLocation> configured,
-                        ResourceLocation itemId
+                        Ingredient ingredient
         ) {
-                var res = get(itemId);
-                if (res.isPresent() || configured.contains(itemId)) {
-                        return res;
-                }
-
-                configured.add(itemId);
-                var item = BuiltInRegistries.ITEM.get(itemId);
-                res = recipes.stream()
-                                .filter(recipe -> recipe.output().is(item))
-                                .map(recipe -> calculateEmcForRecipe(recipes, configured, recipe))
-                                .flatMapToDouble(OptionalDouble::stream)
+                return Arrays.stream(ingredient.getItems())
+                                .map(stack -> configEmc(recipes, configured, ItemUtils.getId(stack.getItem())).stream()
+                                                .map(x -> x * stack.getCount())
+                                                .findFirst())
+                                .filter(OptionalDouble::isPresent)
+                                .mapToDouble(OptionalDouble::getAsDouble)
+                                .filter(x -> x > 0)
                                 .average();
-                res.ifPresentOrElse(
-                                emc -> data.put(itemId, OptionalDouble.of(emc)),
-                                () -> configured.remove(itemId)
-                );
-                return res;
         }
 
-        private OptionalDouble calculateEmcForRecipe(
+        private static OptionalDouble calculateEmcForRecipe(
                         List<SimplifiedRecipe> recipes,
                         Set<ResourceLocation> configured,
                         SimplifiedRecipe recipe
@@ -197,18 +170,87 @@ public class Emc {
                 }
         }
 
-        private OptionalDouble calculateEmcForIngredient(
+        private static OptionalDouble configEmc(
                         List<SimplifiedRecipe> recipes,
                         Set<ResourceLocation> configured,
-                        Ingredient ingredient
+                        ResourceLocation itemId
         ) {
-                return Arrays.stream(ingredient.getItems())
-                                .map(stack -> configEmc(recipes, configured, ItemUtils.getId(stack.getItem())).stream()
-                                                .map(x -> x * stack.getCount())
-                                                .findFirst())
-                                .filter(OptionalDouble::isPresent)
-                                .mapToDouble(OptionalDouble::getAsDouble)
-                                .filter(x -> x > 0)
+                var res = get(itemId);
+                if (res.isPresent() || configured.contains(itemId)) {
+                        return res;
+                }
+
+                configured.add(itemId);
+                var item = BuiltInRegistries.ITEM.get(itemId);
+                res = recipes.stream()
+                                .filter(recipe -> recipe.output().is(item))
+                                .map(recipe -> calculateEmcForRecipe(recipes, configured, recipe))
+                                .flatMapToDouble(OptionalDouble::stream)
                                 .average();
+                res.ifPresentOrElse(
+                                emc -> VALUES.put(itemId, OptionalDouble.of(emc)),
+                                () -> configured.remove(itemId)
+                );
+                return res;
+        }
+
+        private static List<SimplifiedRecipe> getRecipes(@Nullable Level world) {
+                Stream<SimplifiedRecipe> recipes = FAKE_RECIPES.stream();
+
+                if (world != null) {
+                        recipes = Stream.concat(
+                                        recipes,
+                                        world.getRecipeManager()
+                                                        .getRecipes()
+                                                        .stream()
+                                                        .map(recipe -> new SimplifiedRecipe(recipe, world.registryAccess()))
+                        );
+                }
+
+                return recipes.toList();
+        }
+
+        private static void reinit() {
+                VALUES.clear();
+                VALUES.putAll(ITEM_VALUES);
+                ITEM_TAG_VALUES.forEach(
+                                (tag, emcValue) -> BuiltInRegistries.ITEM
+                                                .getTagOrEmpty(tag)
+                                                .forEach(holder -> VALUES.putIfAbsent(ItemUtils.getId(holder), emcValue))
+                );
+                BLOCK_TAG_VALUES.forEach(
+                                (tag, emcValue) -> BuiltInRegistries.BLOCK
+                                                .getTagOrEmpty(tag)
+                                                .forEach(holder -> VALUES.putIfAbsent(ItemUtils.getId(holder), emcValue))
+                );
+
+                ErisAlchemy.LOGGER.info("Calculating EMC values from recipes...");
+                var recipes = getRecipes(overworld);
+                var configured = new HashSet<>(VALUES.keySet());
+                BuiltInRegistries.ITEM.keySet().forEach(item -> configEmc(recipes, configured, item));
+
+                sync();
+        }
+
+        private static void sync() {
+                syncTo(PlayerUtils.all());
+        }
+
+        private static void syncTo(Collection<ServerPlayer> player) {
+                var buf = PacketByteBufs.create();
+                buf.writeMap(VALUES, FriendlyByteBuf::writeResourceLocation, BufUtils::writeOptionalDouble);
+                ServerPlayNetworking.send(player, NetworkingConstants.UPDATE_EMCS, buf);
+        }
+
+        private static void warnOfMissingValues() {
+                if (overworld == null) {
+                        return;
+                }
+
+                BuiltInRegistries.ITEM
+                                .keySet()
+                                .stream()
+                                .filter(item -> !VALUES.containsKey(item))
+                                .forEach(item -> ErisAlchemy.LOGGER.warn("No EMC value for '{}' known", item));
         }
 }