diff --git a/src/main/java/mekanism/common/network/PacketFlamethrowerData.java b/src/main/java/mekanism/common/network/PacketFlamethrowerData.java index 1557a169a..9be8c7f22 100644 --- a/src/main/java/mekanism/common/network/PacketFlamethrowerData.java +++ b/src/main/java/mekanism/common/network/PacketFlamethrowerData.java @@ -12,92 +12,80 @@ import net.minecraftforge.fml.common.network.simpleimpl.IMessage; import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler; import net.minecraftforge.fml.common.network.simpleimpl.MessageContext; -public class PacketFlamethrowerData implements IMessageHandler -{ - @Override - public IMessage onMessage(FlamethrowerDataMessage message, MessageContext context) - { +public class PacketFlamethrowerData implements IMessageHandler { + @Override + public IMessage onMessage(FlamethrowerDataMessage message, MessageContext context) { // Queue up the processing on the central thread EntityPlayer player = PacketHandler.getPlayer(context); - PacketHandler.handlePacket(() -> { - if (message.packetType == FlamethrowerPacket.UPDATE) { - Mekanism.playerState.setFlamethrowerState(message.username, message.value, false); + PacketHandler.handlePacket( + () -> { + if (message.packetType == FlamethrowerPacket.UPDATE) { + Mekanism.playerState.setFlamethrowerState(message.username, message.value, false); - // If we got this packet on the server, resend out to all clients in same dimension - // TODO: Why is this a dimensional thing?! - if (!player.world.isRemote) { - Mekanism.packetHandler.sendToDimension(message, player.world.provider.getDimension()); - } - } else if (message.packetType == FlamethrowerPacket.MODE) { - ItemStack stack = player.getHeldItem(message.currentHand); - if (!stack.isEmpty() && stack.getItem() instanceof ItemFlamethrower) { - ((ItemFlamethrower) stack.getItem()).incrementMode(stack); - } + // If we got this packet on the server, resend out to all clients in same dimension + // TODO: Why is this a dimensional thing?! + if (!player.world.isRemote) { + Mekanism.packetHandler.sendToDimension(message, player.world.provider.getDimension()); + } + } else if (message.packetType == FlamethrowerPacket.MODE) { + ItemStack stack = player.getHeldItem(message.currentHand); + if (!stack.isEmpty() && stack.getItem() instanceof ItemFlamethrower) { + ((ItemFlamethrower) stack.getItem()).incrementMode(stack); + } + } + }, + player); + return null; + } + + public enum FlamethrowerPacket { + UPDATE, + MODE + } + + public static class FlamethrowerDataMessage implements IMessage { + public FlamethrowerPacket packetType; + + public EnumHand currentHand; + public String username; + public boolean value; + + public FlamethrowerDataMessage() {} + + public FlamethrowerDataMessage( + FlamethrowerPacket type, EnumHand hand, String name, boolean state) { + packetType = type; + + if (type == FlamethrowerPacket.UPDATE) { + username = name; + value = state; + } else if (type == FlamethrowerPacket.MODE) { + currentHand = hand; } - }, player); - return null; - } - - public static class FlamethrowerDataMessage implements IMessage - { - public FlamethrowerPacket packetType; - - public EnumHand currentHand; - public String username; - public boolean value; - - public FlamethrowerDataMessage() {} - - public FlamethrowerDataMessage(FlamethrowerPacket type, EnumHand hand, String name, boolean state) - { - packetType = type; - - if(type == FlamethrowerPacket.UPDATE) - { - username = name; - value = state; - } - else if(type == FlamethrowerPacket.MODE) - { - currentHand = hand; - } - } - - @Override - public void toBytes(ByteBuf dataStream) - { - dataStream.writeInt(packetType.ordinal()); - - if(packetType == FlamethrowerPacket.UPDATE) - { - PacketHandler.writeString(dataStream, username); - dataStream.writeBoolean(value); - } - else { - dataStream.writeInt(currentHand.ordinal()); - } - } - - @Override - public void fromBytes(ByteBuf dataStream) - { - packetType = FlamethrowerPacket.values()[dataStream.readInt()]; - - if(packetType == FlamethrowerPacket.UPDATE) - { - username = PacketHandler.readString(dataStream); - value = dataStream.readBoolean(); - } - else if(packetType == FlamethrowerPacket.MODE) - { - currentHand = EnumHand.values()[dataStream.readInt()]; - } - } - } - - public enum FlamethrowerPacket - { - UPDATE, - MODE } + + @Override + public void toBytes(ByteBuf dataStream) { + dataStream.writeInt(packetType.ordinal()); + + if (packetType == FlamethrowerPacket.UPDATE) { + PacketHandler.writeString(dataStream, username); + dataStream.writeBoolean(value); + } else { + dataStream.writeInt(currentHand.ordinal()); + } + } + + @Override + public void fromBytes(ByteBuf dataStream) { + packetType = FlamethrowerPacket.values()[dataStream.readInt()]; + + if (packetType == FlamethrowerPacket.UPDATE) { + username = PacketHandler.readString(dataStream); + value = dataStream.readBoolean(); + } else if (packetType == FlamethrowerPacket.MODE) { + currentHand = EnumHand.values()[dataStream.readInt()]; + } + } + } } diff --git a/src/main/java/mekanism/common/network/PacketJetpackData.java b/src/main/java/mekanism/common/network/PacketJetpackData.java index 40fa9fb88..6fa5d28f1 100644 --- a/src/main/java/mekanism/common/network/PacketJetpackData.java +++ b/src/main/java/mekanism/common/network/PacketJetpackData.java @@ -1,6 +1,8 @@ package mekanism.common.network; import io.netty.buffer.ByteBuf; +import java.util.HashSet; +import java.util.Set; import mekanism.common.Mekanism; import mekanism.common.PacketHandler; import mekanism.common.item.ItemJetpack; @@ -13,15 +15,10 @@ import net.minecraftforge.fml.common.network.simpleimpl.IMessage; import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler; import net.minecraftforge.fml.common.network.simpleimpl.MessageContext; -import java.util.HashSet; -import java.util.Set; - -public class PacketJetpackData implements IMessageHandler -{ - @Override - public IMessage onMessage(JetpackDataMessage message, MessageContext context) - { - // Queue up the processing on the central thread +public class PacketJetpackData implements IMessageHandler { + @Override + public IMessage onMessage(JetpackDataMessage message, MessageContext context) { + // Queue up the processing on the central thread EntityPlayer player = PacketHandler.getPlayer(context); PacketHandler.handlePacket( () -> { @@ -50,89 +47,82 @@ public class PacketJetpackData implements IMessageHandler activeJetpacks; + public enum JetpackPacket { + UPDATE, + FULL, + MODE + } - protected String username; - protected boolean value; - - public JetpackDataMessage() {} + public static class JetpackDataMessage implements IMessage { + protected JetpackPacket packetType; - public JetpackDataMessage(JetpackPacket type) { - packetType = type; - } + protected Set activeJetpacks; - public static JetpackDataMessage MODE_CHANGE(boolean change) { - JetpackDataMessage m = new JetpackDataMessage(JetpackPacket.MODE); - m.value = change; - return m; - } + protected String username; + protected boolean value; - public static JetpackDataMessage UPDATE(String name, boolean state) { - JetpackDataMessage m = new JetpackDataMessage(JetpackPacket.UPDATE); - m.username = name; - m.value = state; - return m; - } + public JetpackDataMessage() {} - public static JetpackDataMessage FULL(Set activeNames) { - JetpackDataMessage m = new JetpackDataMessage(JetpackPacket.FULL); - m.activeJetpacks = activeNames; - return m; - } - - @Override - public void toBytes(ByteBuf dataStream) { - dataStream.writeInt(packetType.ordinal()); - - if(packetType == JetpackPacket.MODE) { - dataStream.writeBoolean(value); - } - else if(packetType == JetpackPacket.UPDATE) { - PacketHandler.writeString(dataStream, username); - dataStream.writeBoolean(value); - } - else if(packetType == JetpackPacket.FULL) { - dataStream.writeInt(activeJetpacks.size()); - for(String username : activeJetpacks) { - PacketHandler.writeString(dataStream, username); - } - } - } - - @Override - public void fromBytes(ByteBuf dataStream) - { - packetType = JetpackPacket.values()[dataStream.readInt()]; - - if(packetType == JetpackPacket.MODE) { - value = dataStream.readBoolean(); - } - else if(packetType == JetpackPacket.UPDATE) { - username = PacketHandler.readString(dataStream); - value = dataStream.readBoolean(); - } - else if(packetType == JetpackPacket.FULL) { - activeJetpacks = new HashSet<>(); - - int amount = dataStream.readInt(); - for(int i = 0; i < amount; i++) { - activeJetpacks.add(PacketHandler.readString(dataStream)); - } - } - } - } - - public enum JetpackPacket - { - UPDATE, - FULL, - MODE + public JetpackDataMessage(JetpackPacket type) { + packetType = type; } + + public static JetpackDataMessage MODE_CHANGE(boolean change) { + JetpackDataMessage m = new JetpackDataMessage(JetpackPacket.MODE); + m.value = change; + return m; + } + + public static JetpackDataMessage UPDATE(String name, boolean state) { + JetpackDataMessage m = new JetpackDataMessage(JetpackPacket.UPDATE); + m.username = name; + m.value = state; + return m; + } + + public static JetpackDataMessage FULL(Set activeNames) { + JetpackDataMessage m = new JetpackDataMessage(JetpackPacket.FULL); + m.activeJetpacks = activeNames; + return m; + } + + @Override + public void toBytes(ByteBuf dataStream) { + dataStream.writeInt(packetType.ordinal()); + + if (packetType == JetpackPacket.MODE) { + dataStream.writeBoolean(value); + } else if (packetType == JetpackPacket.UPDATE) { + PacketHandler.writeString(dataStream, username); + dataStream.writeBoolean(value); + } else if (packetType == JetpackPacket.FULL) { + dataStream.writeInt(activeJetpacks.size()); + for (String username : activeJetpacks) { + PacketHandler.writeString(dataStream, username); + } + } + } + + @Override + public void fromBytes(ByteBuf dataStream) { + packetType = JetpackPacket.values()[dataStream.readInt()]; + + if (packetType == JetpackPacket.MODE) { + value = dataStream.readBoolean(); + } else if (packetType == JetpackPacket.UPDATE) { + username = PacketHandler.readString(dataStream); + value = dataStream.readBoolean(); + } else if (packetType == JetpackPacket.FULL) { + activeJetpacks = new HashSet<>(); + + int amount = dataStream.readInt(); + for (int i = 0; i < amount; i++) { + activeJetpacks.add(PacketHandler.readString(dataStream)); + } + } + } + } } diff --git a/src/main/java/mekanism/common/network/PacketScubaTankData.java b/src/main/java/mekanism/common/network/PacketScubaTankData.java index 0ac29238c..b7d6cc417 100644 --- a/src/main/java/mekanism/common/network/PacketScubaTankData.java +++ b/src/main/java/mekanism/common/network/PacketScubaTankData.java @@ -1,6 +1,8 @@ package mekanism.common.network; import io.netty.buffer.ByteBuf; +import java.util.HashSet; +import java.util.Set; import mekanism.common.Mekanism; import mekanism.common.PacketHandler; import mekanism.common.item.ItemScubaTank; @@ -12,120 +14,109 @@ import net.minecraftforge.fml.common.network.simpleimpl.IMessage; import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler; import net.minecraftforge.fml.common.network.simpleimpl.MessageContext; -import java.util.HashSet; -import java.util.Set; +public class PacketScubaTankData implements IMessageHandler { + @Override + public IMessage onMessage(ScubaTankDataMessage message, MessageContext context) { + // Queue up processing on the central thread + EntityPlayer player = PacketHandler.getPlayer(context); + PacketHandler.handlePacket( + () -> { + if (message.packetType == ScubaTankPacket.UPDATE) { + Mekanism.playerState.setGasmaskState(message.username, message.value, false); -public class PacketScubaTankData implements IMessageHandler -{ - @Override - public IMessage onMessage(ScubaTankDataMessage message, MessageContext context) - { - // Queue up processing on the central thread - EntityPlayer player = PacketHandler.getPlayer(context); - PacketHandler.handlePacket(() ->{ - if(message.packetType == ScubaTankPacket.UPDATE) { - Mekanism.playerState.setGasmaskState(message.username, message.value, false); + // If we got this on the server, relay out to all players in the same dimension + // TODO: Why is this a dimensional thing?! + if (!player.world.isRemote) { + Mekanism.packetHandler.sendToDimension(message, player.world.provider.getDimension()); + } + } else if (message.packetType == ScubaTankPacket.MODE) { + // Use has changed the mode of their gasmask; update it + ItemStack stack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST); + if (!stack.isEmpty() && stack.getItem() instanceof ItemScubaTank) { + ((ItemScubaTank) stack.getItem()).toggleFlowing(stack); + } + } else if (message.packetType == ScubaTankPacket.FULL) { + // This is a full sync; merge into our player state + Mekanism.playerState.setActiveGasmasks(message.activeGasmasks); + } + }, + player); + return null; + } - // If we got this on the server, relay out to all players in the same dimension - // TODO: Why is this a dimensional thing?! - if(!player.world.isRemote) { - Mekanism.packetHandler.sendToDimension(message, player.world.provider.getDimension()); - } - } - else if(message.packetType == ScubaTankPacket.MODE) { - // Use has changed the mode of their gasmask; update it - ItemStack stack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST); - if(!stack.isEmpty() && stack.getItem() instanceof ItemScubaTank) { - ((ItemScubaTank)stack.getItem()).toggleFlowing(stack); - } - } - else if (message.packetType == ScubaTankPacket.FULL) { - // This is a full sync; merge into our player state - Mekanism.playerState.setActiveGasmasks(message.activeGasmasks); - } - }, player); - return null; - } - - public static class ScubaTankDataMessage implements IMessage - { - protected ScubaTankPacket packetType; + public enum ScubaTankPacket { + UPDATE, + FULL, + MODE + } - protected Set activeGasmasks; - - protected String username; - protected boolean value; - - public ScubaTankDataMessage() {} + public static class ScubaTankDataMessage implements IMessage { + protected ScubaTankPacket packetType; - public ScubaTankDataMessage(ScubaTankPacket type) { packetType = type; } + protected Set activeGasmasks; - public static ScubaTankDataMessage MODE_CHANGE(boolean change) { - ScubaTankDataMessage m = new ScubaTankDataMessage(ScubaTankPacket.MODE); - m.value = change; - return m; - } + protected String username; + protected boolean value; - public static ScubaTankDataMessage UPDATE(String name, boolean state) { - ScubaTankDataMessage m = new ScubaTankDataMessage(ScubaTankPacket.UPDATE); - m.username = name; - m.value = state; - return m; - } + public ScubaTankDataMessage() {} - public static ScubaTankDataMessage FULL(Set activeNames) { - ScubaTankDataMessage m = new ScubaTankDataMessage((ScubaTankPacket.FULL)); - m.activeGasmasks = activeNames; - return m; - } - - @Override - public void toBytes(ByteBuf dataStream) - { - dataStream.writeInt(packetType.ordinal()); - - if (packetType == ScubaTankPacket.MODE) { - dataStream.writeBoolean(value); - } - else if(packetType == ScubaTankPacket.UPDATE) { - PacketHandler.writeString(dataStream, username); - dataStream.writeBoolean(value); - } - else if(packetType == ScubaTankPacket.FULL) { - dataStream.writeInt(activeGasmasks.size()); - for (String name : activeGasmasks) { - PacketHandler.writeString(dataStream, name); - } - } - } - - @Override - public void fromBytes(ByteBuf dataStream) - { - packetType = ScubaTankPacket.values()[dataStream.readInt()]; - - if (packetType == ScubaTankPacket.MODE) { - value = dataStream.readBoolean(); - } - else if(packetType == ScubaTankPacket.UPDATE) { - username = PacketHandler.readString(dataStream); - value = dataStream.readBoolean(); - } - else if(packetType == ScubaTankPacket.FULL) { - activeGasmasks = new HashSet<>(); - - int amount = dataStream.readInt(); - for(int i = 0; i < amount; i++) { - activeGasmasks.add(PacketHandler.readString(dataStream)); - } - } - } - } - - public enum ScubaTankPacket - { - UPDATE, - FULL, - MODE + public ScubaTankDataMessage(ScubaTankPacket type) { + packetType = type; } + + public static ScubaTankDataMessage MODE_CHANGE(boolean change) { + ScubaTankDataMessage m = new ScubaTankDataMessage(ScubaTankPacket.MODE); + m.value = change; + return m; + } + + public static ScubaTankDataMessage UPDATE(String name, boolean state) { + ScubaTankDataMessage m = new ScubaTankDataMessage(ScubaTankPacket.UPDATE); + m.username = name; + m.value = state; + return m; + } + + public static ScubaTankDataMessage FULL(Set activeNames) { + ScubaTankDataMessage m = new ScubaTankDataMessage((ScubaTankPacket.FULL)); + m.activeGasmasks = activeNames; + return m; + } + + @Override + public void toBytes(ByteBuf dataStream) { + dataStream.writeInt(packetType.ordinal()); + + if (packetType == ScubaTankPacket.MODE) { + dataStream.writeBoolean(value); + } else if (packetType == ScubaTankPacket.UPDATE) { + PacketHandler.writeString(dataStream, username); + dataStream.writeBoolean(value); + } else if (packetType == ScubaTankPacket.FULL) { + dataStream.writeInt(activeGasmasks.size()); + for (String name : activeGasmasks) { + PacketHandler.writeString(dataStream, name); + } + } + } + + @Override + public void fromBytes(ByteBuf dataStream) { + packetType = ScubaTankPacket.values()[dataStream.readInt()]; + + if (packetType == ScubaTankPacket.MODE) { + value = dataStream.readBoolean(); + } else if (packetType == ScubaTankPacket.UPDATE) { + username = PacketHandler.readString(dataStream); + value = dataStream.readBoolean(); + } else if (packetType == ScubaTankPacket.FULL) { + activeGasmasks = new HashSet<>(); + + int amount = dataStream.readInt(); + for (int i = 0; i < amount; i++) { + activeGasmasks.add(PacketHandler.readString(dataStream)); + } + } + } + } }