diff --git a/src/main/java/com/pahimar/ee3/api/blacklist/BlacklistRegistryProxy.java b/src/main/java/com/pahimar/ee3/api/blacklist/BlacklistRegistryProxy.java index a8dca6fa..4f58635b 100644 --- a/src/main/java/com/pahimar/ee3/api/blacklist/BlacklistRegistryProxy.java +++ b/src/main/java/com/pahimar/ee3/api/blacklist/BlacklistRegistryProxy.java @@ -1,10 +1,53 @@ package com.pahimar.ee3.api.blacklist; import com.pahimar.ee3.EquivalentExchange3; +import com.pahimar.ee3.exchange.WrappedStack; import cpw.mods.fml.common.Mod; +import java.util.Set; + public class BlacklistRegistryProxy { + /** + * TODO Finis JavaDoc + * + * @return + */ + public static Set getKnowledgeBlacklist() { + return getBlacklist(Blacklist.KNOWLEDGE); + } + + /** + * TODO Finish JavaDoc + * + * @return + */ + public static Set getExchangeBlacklist() { + return getBlacklist(Blacklist.EXCHANGE); + } + + /** + * TODO Finish JavaDoc + * + * @param blacklist + * @return + */ + public static Set getBlacklist(Blacklist blacklist) { + + init(); + + if (ee3Mod != null) { + if (blacklist == Blacklist.KNOWLEDGE) { + return EE3Wrapper.ee3mod.getBlacklistRegistry().getKnowledgeBlacklist(); + } + else if (blacklist == Blacklist.EXCHANGE) { + return EE3Wrapper.ee3mod.getBlacklistRegistry().getExchangeBlacklist(); + } + } + + return null; + } + /** * TODO Finish JavaDoc * diff --git a/src/main/java/com/pahimar/ee3/api/exchange/EnergyValueRegistryProxy.java b/src/main/java/com/pahimar/ee3/api/exchange/EnergyValueRegistryProxy.java index d5b3428e..f5ab6643 100644 --- a/src/main/java/com/pahimar/ee3/api/exchange/EnergyValueRegistryProxy.java +++ b/src/main/java/com/pahimar/ee3/api/exchange/EnergyValueRegistryProxy.java @@ -1,17 +1,50 @@ package com.pahimar.ee3.api.exchange; import com.pahimar.ee3.EquivalentExchange3; +import com.pahimar.ee3.exchange.WrappedStack; import cpw.mods.fml.common.Mod; import java.util.ArrayList; import java.util.Collections; import java.util.List; +import java.util.Map; public final class EnergyValueRegistryProxy { @Mod.Instance("EE3") private static Object ee3Mod; + public static Map getPreCalculationEnergyValues() { + return getEnergyValues(Phase.PRE_CALCULATION); + } + + public static Map getPostCalculationEnergyValues() { + return getEnergyValues(Phase.POST_CALCULATION); + } + + public static Map getEnergyValues() { + return getEnergyValues(Phase.ALL); + } + + public static Map getEnergyValues(Phase phase) { + + init(); + + if (ee3Mod != null) { + if (phase == Phase.PRE_ASSIGNMENT || phase == Phase.PRE_CALCULATION) { + EE3Wrapper.ee3mod.getEnergyValueRegistry().getPreCalculationStackValueMap(); + } + else if (phase == Phase.POST_ASSIGNMENT || phase == Phase.POST_CALCULATION) { + EE3Wrapper.ee3mod.getEnergyValueRegistry().getPostCalculationStackValueMap(); + } + else if (phase == Phase.ALL) { + EE3Wrapper.ee3mod.getEnergyValueRegistry().getEnergyValues(); + } + } + + return null; + } + public static boolean hasEnergyValue(Object object) { return hasEnergyValue(object, false); @@ -200,6 +233,6 @@ public final class EnergyValueRegistryProxy { @Deprecated POST_ASSIGNMENT, POST_CALCULATION, @Deprecated RUNTIME, - @Deprecated ALL + ALL } } diff --git a/src/main/java/com/pahimar/ee3/blacklist/BlacklistRegistry.java b/src/main/java/com/pahimar/ee3/blacklist/BlacklistRegistry.java index 04741dc7..f0d79b67 100644 --- a/src/main/java/com/pahimar/ee3/blacklist/BlacklistRegistry.java +++ b/src/main/java/com/pahimar/ee3/blacklist/BlacklistRegistry.java @@ -5,15 +5,14 @@ import com.pahimar.ee3.exchange.WrappedStack; import com.pahimar.ee3.util.LoaderHelper; import com.pahimar.ee3.util.LogHelper; import com.pahimar.ee3.util.SerializationHelper; -import cpw.mods.fml.common.FMLCommonHandler; import cpw.mods.fml.common.Loader; -import cpw.mods.fml.relauncher.Side; import net.minecraft.item.ItemStack; import net.minecraftforge.common.MinecraftForge; import org.apache.logging.log4j.Marker; import org.apache.logging.log4j.MarkerManager; import java.io.File; +import java.util.Collections; import java.util.Set; import java.util.TreeSet; @@ -31,11 +30,9 @@ public class BlacklistRegistry { private static final Marker EXCHANGE_BLACKLIST_MARKER = MarkerManager.getMarker("EE3_BLACKLIST_EXCHANGE", BLACKLIST_MARKER); private static final Marker EXCHANGE_WHITELIST_MARKER = MarkerManager.getMarker("EE3_WHITELIST_EXCHANGE", BLACKLIST_MARKER); - private final Set knowledgeBlacklist; - private final Set exchangeBlacklist; - - public static File knowledgeBlacklistFile; - public static File exchangeBlacklistFile; + private final Set knowledgeBlacklist, exchangeBlacklist; + public static File knowledgeBlacklistFile, exchangeBlacklistFile; + private transient boolean loadedFromServer; /** * TODO Finish JavaDoc @@ -44,6 +41,25 @@ public class BlacklistRegistry { knowledgeBlacklist = new TreeSet<>(); exchangeBlacklist = new TreeSet<>(); + loadedFromServer = false; + } + + /** + * TODO Finish JavaDoc + * + * @return + */ + public Set getKnowledgeBlacklist() { + return Collections.unmodifiableSet(knowledgeBlacklist); + } + + /** + * TODO Finish JavaDoc + * + * @return + */ + public Set getExchangeBlacklist() { + return Collections.unmodifiableSet(exchangeBlacklist); } /** @@ -148,15 +164,32 @@ public class BlacklistRegistry { * TODO Finish JavaDoc */ public void load() { - if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER){ - LogHelper.trace(BLACKLIST_MARKER, "Loading player knowledge blacklist from {}", knowledgeBlacklistFile.getAbsolutePath()); - knowledgeBlacklist.clear(); - knowledgeBlacklist.addAll(SerializationHelper.readSetFromFile(knowledgeBlacklistFile)); + LogHelper.trace(BLACKLIST_MARKER, "Loading player knowledge blacklist from {}", knowledgeBlacklistFile.getAbsolutePath()); + knowledgeBlacklist.clear(); + knowledgeBlacklist.addAll(SerializationHelper.readSetFromFile(knowledgeBlacklistFile)); - LogHelper.trace(BLACKLIST_MARKER, "Loading exchange blacklist from {}", exchangeBlacklistFile.getAbsolutePath()); - exchangeBlacklist.clear(); - exchangeBlacklist.addAll(SerializationHelper.readSetFromFile(exchangeBlacklistFile)); + LogHelper.trace(BLACKLIST_MARKER, "Loading exchange blacklist from {}", exchangeBlacklistFile.getAbsolutePath()); + exchangeBlacklist.clear(); + exchangeBlacklist.addAll(SerializationHelper.readSetFromFile(exchangeBlacklistFile)); + } + + public void load(Set blacklistSet, Blacklist blacklist) { + + if (blacklist != null && blacklistSet != null) { + + loadedFromServer = true; + + if (blacklist == Blacklist.KNOWLEDGE) { + LogHelper.info("Received {} player knowledge blacklist entries from server", blacklistSet.size()); + knowledgeBlacklist.clear(); + knowledgeBlacklist.addAll(blacklistSet); + } + else if (blacklist == Blacklist.EXCHANGE) { + LogHelper.info("Received {} exchange blacklist entries from server", blacklistSet.size()); + exchangeBlacklist.clear(); + exchangeBlacklist.addAll(blacklistSet); + } } } @@ -167,8 +200,7 @@ public class BlacklistRegistry { */ public void save(Blacklist blacklist) { - if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER) { - + if (!loadedFromServer) { if (blacklist == Blacklist.KNOWLEDGE) { LogHelper.trace(BLACKLIST_MARKER, "Saving player knowledge blacklist to {}", knowledgeBlacklistFile.getAbsolutePath()); SerializationHelper.writeJsonFile(knowledgeBlacklistFile, SerializationHelper.GSON.toJson(knowledgeBlacklist)); @@ -185,7 +217,7 @@ public class BlacklistRegistry { */ public void saveAll() { - if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER) { + if (!loadedFromServer) { LogHelper.trace(BLACKLIST_MARKER, "Saving all blacklists to disk", exchangeBlacklistFile.getAbsolutePath()); SerializationHelper.writeJsonFile(knowledgeBlacklistFile, SerializationHelper.GSON.toJson(knowledgeBlacklist)); SerializationHelper.writeJsonFile(exchangeBlacklistFile, SerializationHelper.GSON.toJson(exchangeBlacklist)); diff --git a/src/main/java/com/pahimar/ee3/command/CommandSetEnergyValue.java b/src/main/java/com/pahimar/ee3/command/CommandSetEnergyValue.java index 73ac330a..9efd2c2c 100644 --- a/src/main/java/com/pahimar/ee3/command/CommandSetEnergyValue.java +++ b/src/main/java/com/pahimar/ee3/command/CommandSetEnergyValue.java @@ -5,6 +5,8 @@ import com.pahimar.ee3.api.exchange.EnergyValue; import com.pahimar.ee3.api.exchange.EnergyValueRegistryProxy; import com.pahimar.ee3.exchange.EnergyValueRegistry; import com.pahimar.ee3.exchange.WrappedStack; +import com.pahimar.ee3.network.PacketHandler; +import com.pahimar.ee3.network.message.MessageSetEnergyValue; import com.pahimar.ee3.reference.Messages; import com.pahimar.ee3.reference.Names; import net.minecraft.command.CommandBase; @@ -97,6 +99,7 @@ public class CommandSetEnergyValue extends CommandBase } else if (args[1].equalsIgnoreCase("post")) { EnergyValueRegistryProxy.setEnergyValue(wrappedStack, newEnergyValue); + PacketHandler.INSTANCE.sendToAll(new MessageSetEnergyValue(wrappedStack, newEnergyValue)); } else { throw new WrongUsageException(Messages.Commands.SET_ENERGY_VALUE_USAGE); @@ -110,6 +113,8 @@ public class CommandSetEnergyValue extends CommandBase BlacklistRegistryProxy.setAsNotLearnable(wrappedStack); BlacklistRegistryProxy.setAsNotExchangeable(wrappedStack); + // TODO Remove energy value from EnergyValueRegistry + // TODO Sync change with client func_152373_a(commandSender, this, "%s set %s as not learnable and not exchangeable", new Object[]{commandSender.getCommandSenderName(), itemStack.func_151000_E()}); } } diff --git a/src/main/java/com/pahimar/ee3/command/CommandSetEnergyValueCurrentItem.java b/src/main/java/com/pahimar/ee3/command/CommandSetEnergyValueCurrentItem.java index 531a6f5c..868a4e8a 100644 --- a/src/main/java/com/pahimar/ee3/command/CommandSetEnergyValueCurrentItem.java +++ b/src/main/java/com/pahimar/ee3/command/CommandSetEnergyValueCurrentItem.java @@ -5,6 +5,8 @@ import com.pahimar.ee3.api.exchange.EnergyValue; import com.pahimar.ee3.api.exchange.EnergyValueRegistryProxy; import com.pahimar.ee3.exchange.EnergyValueRegistry; import com.pahimar.ee3.exchange.WrappedStack; +import com.pahimar.ee3.network.PacketHandler; +import com.pahimar.ee3.network.message.MessageSetEnergyValue; import com.pahimar.ee3.reference.Messages; import com.pahimar.ee3.reference.Names; import net.minecraft.command.CommandBase; @@ -67,6 +69,7 @@ public class CommandSetEnergyValueCurrentItem extends CommandBase } else if (args[1].equalsIgnoreCase("post")) { EnergyValueRegistryProxy.setEnergyValue(wrappedStack, newEnergyValue); + PacketHandler.INSTANCE.sendToAll(new MessageSetEnergyValue(wrappedStack, newEnergyValue)); } else { throw new WrongUsageException(Messages.Commands.SET_ENERGY_VALUE_CURRENT_ITEM_USAGE); @@ -79,6 +82,8 @@ public class CommandSetEnergyValueCurrentItem extends CommandBase BlacklistRegistryProxy.setAsNotLearnable(wrappedStack); BlacklistRegistryProxy.setAsNotExchangeable(wrappedStack); + // TODO Remove energy value from EnergyValueRegistry + // TODO Sync change with client func_152373_a(commandSender, this, "%s set %s as not learnable and not exchangeable", new Object[]{commandSender.getCommandSenderName(), itemStack.func_151000_E()}); } } diff --git a/src/main/java/com/pahimar/ee3/exchange/EnergyValueRegistry.java b/src/main/java/com/pahimar/ee3/exchange/EnergyValueRegistry.java index e2346cdd..fcfc5044 100644 --- a/src/main/java/com/pahimar/ee3/exchange/EnergyValueRegistry.java +++ b/src/main/java/com/pahimar/ee3/exchange/EnergyValueRegistry.java @@ -37,7 +37,8 @@ public class EnergyValueRegistry { private final Map preCalculationStackValueMap; private final Map postCalculationStackValueMap; private transient SortedSet uncomputedStacks; - private transient boolean loadedFromMap; + private transient boolean shouldSave; + private transient boolean valuesNeedRegeneration; public static File energyValuesDirectory; public static File energyValuesFile; @@ -54,7 +55,7 @@ public class EnergyValueRegistry { preCalculationStackValueMap = new TreeMap<>(); postCalculationStackValueMap = new TreeMap<>(); uncomputedStacks = new TreeSet<>(); - loadedFromMap = false; + shouldSave = true; } /** @@ -504,6 +505,9 @@ public class EnergyValueRegistry { if (doRegenValues) { compute(); } + else { + valuesNeedRegeneration = true; + } } } else if (!FMLCommonHandler.instance().bus().post(new EnergyValueEvent.SetEnergyValueEvent(wrappedStack, factoredEnergyValue, Phase.POST_CALCULATION))) { @@ -522,6 +526,10 @@ public class EnergyValueRegistry { } } + public void setShouldSave(boolean shouldSave) { + this.shouldSave = shouldSave; + } + /** * TODO Finish JavaDoc * @@ -529,10 +537,14 @@ public class EnergyValueRegistry { */ public void compute() { + valuesNeedRegeneration = false; + // Initialize the "working copy" energy value map final Map stackValueMap = new TreeMap<>(); uncomputedStacks = new TreeSet<>(); + // TODO Potentially read in values from pre-calculation file to capture file edits + // Add in all pre-calculation energy value mappings preCalculationStackValueMap.keySet().stream() .filter(wrappedStack -> wrappedStack != null && wrappedStack.getWrappedObject() != null && preCalculationStackValueMap.get(wrappedStack) != null) @@ -541,6 +553,8 @@ public class EnergyValueRegistry { // Calculate values from the known methods to create items, and the pre-calculation value mappings stackValueMap.putAll(calculateStackValueMap(stackValueMap)); + // TODO Potentially read in values from post-calculation file to capture file edits + // Add in all post-calculation energy value mappings postCalculationStackValueMap.keySet().stream() .filter(wrappedStack -> wrappedStack != null && wrappedStack.getWrappedObject() != null && postCalculationStackValueMap.get(wrappedStack) != null) @@ -648,8 +662,15 @@ public class EnergyValueRegistry { * If the current values were synched to us from a server, do not save them to disk as they would override * the local ones */ - if (!loadedFromMap) { - SerializationHelper.writeMapToFile(stackValueMap, energyValuesFile); + if (shouldSave) { + if (valuesNeedRegeneration) { + if (energyValuesFile.exists()) { + energyValuesFile.delete(); + } + } + else { + SerializationHelper.writeMapToFile(stackValueMap, energyValuesFile); + } } SerializationHelper.writeMapToFile(preCalculationStackValueMap, preCalculationValuesFile); SerializationHelper.writeMapToFile(postCalculationStackValueMap, postCalculationValuesFile); @@ -693,9 +714,9 @@ public class EnergyValueRegistry { */ public void load(Map valueMap){ - if (stackValueMap != null) { + if (valueMap != null) { - loadedFromMap = true; + setShouldSave(false); ImmutableSortedMap.Builder stackMappingsBuilder = ImmutableSortedMap.naturalOrder(); stackMappingsBuilder.putAll(valueMap); stackValueMap = stackMappingsBuilder.build(); diff --git a/src/main/java/com/pahimar/ee3/handler/PlayerEventHandler.java b/src/main/java/com/pahimar/ee3/handler/PlayerEventHandler.java index 19988b8a..5ef20221 100644 --- a/src/main/java/com/pahimar/ee3/handler/PlayerEventHandler.java +++ b/src/main/java/com/pahimar/ee3/handler/PlayerEventHandler.java @@ -2,6 +2,7 @@ package com.pahimar.ee3.handler; import com.pahimar.ee3.network.PacketHandler; import com.pahimar.ee3.network.message.MessageChalkSettings; +import com.pahimar.ee3.network.message.MessageSyncBlacklist; import com.pahimar.ee3.network.message.MessageSyncEnergyValues; import com.pahimar.ee3.settings.ChalkSettings; import com.pahimar.ee3.util.EntityHelper; @@ -9,6 +10,8 @@ import cpw.mods.fml.common.eventhandler.SubscribeEvent; import net.minecraft.entity.player.EntityPlayerMP; import net.minecraft.nbt.NBTTagCompound; +import static com.pahimar.ee3.api.blacklist.BlacklistRegistryProxy.Blacklist; + public class PlayerEventHandler { @SubscribeEvent @@ -25,6 +28,8 @@ public class PlayerEventHandler { PacketHandler.INSTANCE.sendTo(new MessageChalkSettings(chalkSettings), (EntityPlayerMP) event.player); PacketHandler.INSTANCE.sendTo(new MessageSyncEnergyValues(), (EntityPlayerMP) event.player); + PacketHandler.INSTANCE.sendTo(new MessageSyncBlacklist(Blacklist.KNOWLEDGE), (EntityPlayerMP) event.player); + PacketHandler.INSTANCE.sendTo(new MessageSyncBlacklist(Blacklist.EXCHANGE), (EntityPlayerMP) event.player); } } } diff --git a/src/main/java/com/pahimar/ee3/network/PacketHandler.java b/src/main/java/com/pahimar/ee3/network/PacketHandler.java index 8d9d42a7..6e6c82dd 100644 --- a/src/main/java/com/pahimar/ee3/network/PacketHandler.java +++ b/src/main/java/com/pahimar/ee3/network/PacketHandler.java @@ -6,12 +6,11 @@ import cpw.mods.fml.common.network.NetworkRegistry; import cpw.mods.fml.common.network.simpleimpl.SimpleNetworkWrapper; import cpw.mods.fml.relauncher.Side; -public class PacketHandler -{ +public class PacketHandler { + public static final SimpleNetworkWrapper INSTANCE = NetworkRegistry.INSTANCE.newSimpleChannel(Reference.LOWERCASE_MOD_ID); - public static void init() - { + public static void init() { INSTANCE.registerMessage(MessageTileEntityEE.class, MessageTileEntityEE.class, 0, Side.CLIENT); INSTANCE.registerMessage(MessageTileCalcinator.class, MessageTileCalcinator.class, 1, Side.CLIENT); INSTANCE.registerMessage(MessageTileEntityAludel.class, MessageTileEntityAludel.class, 2, Side.CLIENT); @@ -30,5 +29,6 @@ public class PacketHandler INSTANCE.registerMessage(MessageSliderElementUpdated.class, MessageSliderElementUpdated.class, 15, Side.SERVER); INSTANCE.registerMessage(MessagePlayerKnowledge.class, MessagePlayerKnowledge.class, 16, Side.CLIENT); INSTANCE.registerMessage(MessageTileEntityResearchStation.class, MessageTileEntityResearchStation.class, 17, Side.CLIENT); + INSTANCE.registerMessage(MessageSyncBlacklist.class, MessageSyncBlacklist.class, 18, Side.CLIENT); } } diff --git a/src/main/java/com/pahimar/ee3/network/message/MessageSetEnergyValue.java b/src/main/java/com/pahimar/ee3/network/message/MessageSetEnergyValue.java index 435537aa..80624057 100644 --- a/src/main/java/com/pahimar/ee3/network/message/MessageSetEnergyValue.java +++ b/src/main/java/com/pahimar/ee3/network/message/MessageSetEnergyValue.java @@ -1,5 +1,6 @@ package com.pahimar.ee3.network.message; +import com.google.gson.JsonParseException; import com.pahimar.ee3.api.exchange.EnergyValue; import com.pahimar.ee3.api.exchange.EnergyValueRegistryProxy; import com.pahimar.ee3.exchange.EnergyValueRegistry; @@ -7,76 +8,96 @@ import com.pahimar.ee3.exchange.EnergyValueStackMapping; import com.pahimar.ee3.exchange.WrappedStack; import com.pahimar.ee3.util.CompressionHelper; import com.pahimar.ee3.util.LogHelper; +import com.pahimar.ee3.util.SerializationHelper; import cpw.mods.fml.common.network.simpleimpl.IMessage; import cpw.mods.fml.common.network.simpleimpl.IMessageHandler; import cpw.mods.fml.common.network.simpleimpl.MessageContext; import io.netty.buffer.ByteBuf; -public class MessageSetEnergyValue implements IMessage, IMessageHandler -{ +import java.util.Map; +import java.util.TreeMap; + +public class MessageSetEnergyValue implements IMessage, IMessageHandler { + + public Map energyValueMap; public EnergyValueStackMapping energyValueStackMapping; - public MessageSetEnergyValue() - { + public MessageSetEnergyValue() { } - public MessageSetEnergyValue(WrappedStack wrappedStack, EnergyValue energyValue) - { + public MessageSetEnergyValue(WrappedStack wrappedStack, EnergyValue energyValue) { + + this.energyValueMap = new TreeMap<>(); + if (wrappedStack != null && wrappedStack.getWrappedObject() != null && energyValue != null) { + this.energyValueMap.put(wrappedStack, energyValue); + } this.energyValueStackMapping = new EnergyValueStackMapping(wrappedStack, energyValue); } + public MessageSetEnergyValue(Map energyValueMap) { + this.energyValueMap = energyValueMap; + } + @Override - public void fromBytes(ByteBuf buf) - { - byte[] compressedEnergyValueStackMapping = null; - int energyValueStackMappingByteCount = buf.readInt(); + public void fromBytes(ByteBuf buf) { - if (energyValueStackMappingByteCount > 0) - { - compressedEnergyValueStackMapping = buf.readBytes(energyValueStackMappingByteCount).array(); + int compressedJsonLength = buf.readInt(); + + if (compressedJsonLength != 0) { + byte[] compressedValueMap = buf.readBytes(compressedJsonLength).array(); + + if (compressedValueMap != null) { + + String jsonString = CompressionHelper.decompress(compressedValueMap); + + try { + energyValueMap = SerializationHelper.GSON.fromJson(jsonString, SerializationHelper.ENERGY_VALUE_MAP_TYPE); + } + catch (JsonParseException e) { + LogHelper.warn("Failed to read energy value map from server"); + energyValueMap = null; + } + } + else { + energyValueMap = null; + } } - - if (compressedEnergyValueStackMapping != null) - { - String decompressedEnergyValueStackMapping = decompressedEnergyValueStackMapping = CompressionHelper.decompress(compressedEnergyValueStackMapping); - this.energyValueStackMapping = EnergyValueStackMapping.createFromJson(decompressedEnergyValueStackMapping); + else { + energyValueMap = null; } } @Override - public void toBytes(ByteBuf buf) - { - byte[] compressedBytes = null; - String jsonEnergyValueStackMapping = this.energyValueStackMapping.toJson(); + public void toBytes(ByteBuf buf) { + if (energyValueMap != null) { - if (jsonEnergyValueStackMapping != null) - { - compressedBytes = CompressionHelper.compress(jsonEnergyValueStackMapping); + byte[] compressedValueMap = CompressionHelper.compress(SerializationHelper.GSON.toJson(energyValueMap, SerializationHelper.ENERGY_VALUE_MAP_TYPE)); + + if (compressedValueMap != null) { + buf.writeInt(compressedValueMap.length); + buf.writeBytes(compressedValueMap); + } + else { + buf.writeInt(0); + } } - - if (compressedBytes != null) - { - buf.writeInt(compressedBytes.length); - buf.writeBytes(compressedBytes); - } - else - { + else { buf.writeInt(0); } } @Override - public IMessage onMessage(MessageSetEnergyValue message, MessageContext ctx) - { - if (message.energyValueStackMapping != null && message.energyValueStackMapping.wrappedStack != null && message.energyValueStackMapping.energyValue != null) - { - EnergyValueRegistryProxy.setEnergyValue(message.energyValueStackMapping.wrappedStack, message.energyValueStackMapping.energyValue); - LogHelper.info(EnergyValueRegistry.ENERGY_VALUE_MARKER, "Client successfully received new EnergyValue '{}' for object '{}'", message.energyValueStackMapping.wrappedStack, message.energyValueStackMapping.energyValue); - } - else - { - LogHelper.info(EnergyValueRegistry.ENERGY_VALUE_MARKER, "Client failed to receive new EnergyValue from server"); + public IMessage onMessage(MessageSetEnergyValue message, MessageContext ctx) { + + if (message.energyValueMap != null) { + for (WrappedStack wrappedStack : message.energyValueMap.keySet()) { + + EnergyValue energyValue = message.energyValueMap.get(wrappedStack); + EnergyValueRegistryProxy.setEnergyValue(wrappedStack, energyValue); + EnergyValueRegistry.INSTANCE.setShouldSave(false); + LogHelper.info(EnergyValueRegistry.ENERGY_VALUE_MARKER, "Client successfully received new energy value '{}' for object '{}'", energyValue, wrappedStack); + } } return null; diff --git a/src/main/java/com/pahimar/ee3/network/message/MessageSyncBlacklist.java b/src/main/java/com/pahimar/ee3/network/message/MessageSyncBlacklist.java new file mode 100644 index 00000000..cc92544a --- /dev/null +++ b/src/main/java/com/pahimar/ee3/network/message/MessageSyncBlacklist.java @@ -0,0 +1,114 @@ +package com.pahimar.ee3.network.message; + +import com.google.gson.JsonParseException; +import com.pahimar.ee3.api.blacklist.BlacklistRegistryProxy; +import com.pahimar.ee3.blacklist.BlacklistRegistry; +import com.pahimar.ee3.exchange.WrappedStack; +import com.pahimar.ee3.util.CompressionHelper; +import com.pahimar.ee3.util.LogHelper; +import com.pahimar.ee3.util.SerializationHelper; +import cpw.mods.fml.common.network.simpleimpl.IMessage; +import cpw.mods.fml.common.network.simpleimpl.IMessageHandler; +import cpw.mods.fml.common.network.simpleimpl.MessageContext; +import io.netty.buffer.ByteBuf; + +import java.util.Set; + +import static com.pahimar.ee3.api.blacklist.BlacklistRegistryProxy.Blacklist; + +public class MessageSyncBlacklist implements IMessage, IMessageHandler { + + public Blacklist blacklist; + public Set blacklistSet; + + public MessageSyncBlacklist() { + } + + public MessageSyncBlacklist(Blacklist blacklist) { + + this.blacklist = blacklist; + this.blacklistSet = BlacklistRegistryProxy.getBlacklist(blacklist); + } + + @Override + public void fromBytes(ByteBuf buf) { + + int blacklistOrdinal = buf.readInt(); + + if (blacklistOrdinal == 0) { + blacklist = Blacklist.KNOWLEDGE; + } + else if (blacklistOrdinal == 1) { + blacklist = Blacklist.EXCHANGE; + } + else { + blacklist = null; + } + + if (blacklist != null) { + + int compressedJsonLength = buf.readInt(); + if (compressedJsonLength != 0) { + + byte[] compressedBlacklist = buf.readBytes(compressedJsonLength).array(); + + if (compressedBlacklist != null) { + + String jsonBlacklist = CompressionHelper.decompress(compressedBlacklist); + + try { + blacklistSet = SerializationHelper.GSON.fromJson(jsonBlacklist, SerializationHelper.WRAPPED_STACK_SET_TYPE); + } + catch (JsonParseException e) { + LogHelper.warn("Failed to receive {} blacklist data from server", blacklist); + blacklistSet = null; + } + } + else { + blacklistSet = null; + } + } + } + else { + blacklistSet = null; + } + } + + @Override + public void toBytes(ByteBuf buf) { + + if (blacklist != null) { + + buf.writeInt(blacklist.ordinal()); + + if (blacklistSet != null) { + + byte[] compressedBlacklist = CompressionHelper.compress(SerializationHelper.GSON.toJson(blacklistSet, SerializationHelper.WRAPPED_STACK_SET_TYPE)); + + if (compressedBlacklist != null) { + buf.writeInt(compressedBlacklist.length); + buf.writeBytes(compressedBlacklist); + } + else { + buf.writeInt(0); + } + } + else { + buf.writeInt(0); + } + } + else { + buf.writeInt(-1); + } + } + + @Override + public IMessage onMessage(MessageSyncBlacklist message, MessageContext ctx) { + + if (message.blacklist != null && message.blacklistSet != null) { + BlacklistRegistry.INSTANCE.load(message.blacklistSet, message.blacklist); + } + + return null; + } +} diff --git a/src/main/java/com/pahimar/ee3/network/message/MessageSyncEnergyValues.java b/src/main/java/com/pahimar/ee3/network/message/MessageSyncEnergyValues.java index 6a168200..b4b681b7 100644 --- a/src/main/java/com/pahimar/ee3/network/message/MessageSyncEnergyValues.java +++ b/src/main/java/com/pahimar/ee3/network/message/MessageSyncEnergyValues.java @@ -16,10 +16,10 @@ import java.util.Map; public class MessageSyncEnergyValues implements IMessage, IMessageHandler { - public String jsonString; + public Map valueMap; public MessageSyncEnergyValues() { - this.jsonString = SerializationHelper.GSON.toJson(EnergyValueRegistry.INSTANCE.getEnergyValues(), SerializationHelper.ENERGY_VALUE_MAP_TYPE); + this.valueMap = EnergyValueRegistry.INSTANCE.getEnergyValues(); } /** @@ -30,15 +30,29 @@ public class MessageSyncEnergyValues implements IMessage, IMessageHandler 0) { - compressedString = buf.readBytes(compressedStringLength).array(); + if (compressedJsonLength != 0) { + byte[] compressedValueMap = buf.readBytes(compressedJsonLength).array(); - if (compressedString != null) { - this.jsonString = CompressionHelper.decompress(compressedString); + if (compressedValueMap != null) { + + String jsonString = CompressionHelper.decompress(compressedValueMap); + + try { + valueMap = SerializationHelper.GSON.fromJson(jsonString, SerializationHelper.ENERGY_VALUE_MAP_TYPE); + } + catch (JsonParseException e) { + LogHelper.warn("Failed to read energy value map from server"); + valueMap = null; + } } + else { + valueMap = null; + } + } + else { + valueMap = null; } } @@ -50,15 +64,13 @@ public class MessageSyncEnergyValues implements IMessage, IMessageHandler valueMap = null; - - try { - valueMap = SerializationHelper.GSON.fromJson(message.jsonString, SerializationHelper.ENERGY_VALUE_MAP_TYPE); - } - catch (JsonParseException e) { - // TODO Log an error message here - } - - if (valueMap != null) { - EnergyValueRegistry.INSTANCE.load(valueMap); - LogHelper.info(EnergyValueRegistry.ENERGY_VALUE_MARKER, "Client successfully received {} energy values from server", valueMap.size()); - } - else { - // TODO Log a message here - } + if (message.valueMap != null) { + EnergyValueRegistry.INSTANCE.load(message.valueMap); + LogHelper.info(EnergyValueRegistry.ENERGY_VALUE_MARKER, "Client successfully received {} energy values from server", message.valueMap.size()); } else { LogHelper.info(EnergyValueRegistry.ENERGY_VALUE_MARKER, "Client failed to receive energy values from server - falling back to local values"); diff --git a/src/main/java/com/pahimar/ee3/util/FluidHelper.java b/src/main/java/com/pahimar/ee3/util/FluidHelper.java index 92934d76..f2101517 100644 --- a/src/main/java/com/pahimar/ee3/util/FluidHelper.java +++ b/src/main/java/com/pahimar/ee3/util/FluidHelper.java @@ -19,28 +19,40 @@ public class FluidHelper { if (fluidStack1 != null && fluidStack2 != null) { if (fluidStack1.getFluid() != null && fluidStack2.getFluid() != null) { - if (FluidRegistry.getFluidName(fluidStack1).equalsIgnoreCase(FluidRegistry.getFluidName(fluidStack2))) { - if (fluidStack1.amount == fluidStack2.amount) { - if (fluidStack1.tag != null && fluidStack2.tag != null) { - return fluidStack1.tag.hashCode() - fluidStack2.tag.hashCode(); - } - else if (fluidStack1.tag != null) { - return -1; - } - else if (fluidStack2.tag != null) { - return 1; + if (FluidRegistry.getFluidName(fluidStack1) != null && FluidRegistry.getFluidName(fluidStack2) != null) { + if (FluidRegistry.getFluidName(fluidStack1).equalsIgnoreCase(FluidRegistry.getFluidName(fluidStack2))) { + if (fluidStack1.amount == fluidStack2.amount) { + if (fluidStack1.tag != null && fluidStack2.tag != null) { + return fluidStack1.tag.hashCode() - fluidStack2.tag.hashCode(); + } + else if (fluidStack1.tag != null) { + return -1; + } + else if (fluidStack2.tag != null) { + return 1; + } + else { + return 0; + } } else { - return 0; + return fluidStack1.amount - fluidStack2.amount; } } else { - return fluidStack1.amount - fluidStack2.amount; + return FluidRegistry.getFluidName(fluidStack1).compareToIgnoreCase(FluidRegistry.getFluidName(fluidStack2)); } } - else { - return FluidRegistry.getFluidName(fluidStack1).compareToIgnoreCase(FluidRegistry.getFluidName(fluidStack2)); + else if (FluidRegistry.getFluidName(fluidStack1) != null) { + return -1; } + else if (FluidRegistry.getFluidName(fluidStack2) != null) { + return 1; + } + else { + return 0; + } + } else if (fluidStack1.getFluid() != null) { return -1; @@ -69,8 +81,7 @@ public class FluidHelper { // Register Milk in the FluidRegistry if it hasn't already been done if (!FluidRegistry.isFluidRegistered("milk")) { Fluid milk = new Fluid("milk").setUnlocalizedName(Names.Fluids.MILK); - if (FluidRegistry.registerFluid(milk)) - { + if (FluidRegistry.registerFluid(milk)) { FluidContainerRegistry.registerFluidContainer(new FluidStack(milk, 1000), new ItemStack(Items.milk_bucket), new ItemStack(Items.bucket)); } }