Jika/oc2r
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add message base class to make registration a lot less boiler-platey.

Browse Source
This commit is contained in:
Florian Nücke
2021-07-28 01:45:46 +02:00
parent 20b16ce7cb
commit b75b4106fb
28 changed files with 457 additions and 472 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
src/main/java/li/cil/oc2/common/network/MessageUtils.java
View File

@@ -11,13 +11,12 @@ import net.minecraft.world.server.ServerWorld;
import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Consumer;
import java.util.function.Supplier;
public final class MessageUtils {
@SuppressWarnings("unchecked")
public static <T extends TileEntity> void withServerTileEntityAt(final Supplier<NetworkEvent.Context> context, final BlockPos pos, final Class<T> type, final Consumer<T> callback) {
final ServerPlayerEntity player = context.get().getSender();
if (player == null) {
public static <T extends TileEntity> void withNearbyServerTileEntityAt(final NetworkEvent.Context context, final BlockPos pos, final Class<T> type, final Consumer<T> callback) {
final ServerPlayerEntity player = context.getSender();
if (player == null || !pos.closerThan(player.position(), 8)) {
return;
}
@@ -29,8 +28,8 @@ public final class MessageUtils {
}
@SuppressWarnings("unchecked")
public static <T extends Entity> void withServerEntity(final Supplier<NetworkEvent.Context> context, final int id, final Class<T> type, final Consumer<T> callback) {
final ServerPlayerEntity player = context.get().getSender();
public static <T extends Entity> void withServerEntity(final NetworkEvent.Context context, final int id, final Class<T> type, final Consumer<T> callback) {
final ServerPlayerEntity player = context.getSender();
if (player == null) {
return;
}
@@ -42,6 +41,20 @@ public final class MessageUtils {
}
}
@SuppressWarnings("unchecked")
public static <T extends Entity> void withNearbyServerEntity(final NetworkEvent.Context context, final int id, final Class<T> type, final Consumer<T> callback) {
final ServerPlayerEntity player = context.getSender();
if (player == null) {
return;
}
final ServerWorld world = player.getLevel();
final Entity entity = world.getEntity(id);
if (type.isInstance(entity) && entity.closerThan(player, 8)) {
callback.accept((T) entity);
}
}
@SuppressWarnings("unchecked")
public static <T extends TileEntity> void withClientTileEntityAt(final BlockPos pos, final Class<T> type, final Consumer<T> callback) {
final ClientWorld world = Minecraft.getInstance().level;

172
src/main/java/li/cil/oc2/common/network/Network.java
View File

@@ -3,6 +3,7 @@ package li.cil.oc2.common.network;
import li.cil.oc2.api.API;
import li.cil.oc2.common.network.message.*;
import net.minecraft.entity.Entity;
import net.minecraft.network.PacketBuffer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.chunk.Chunk;
@@ -11,6 +12,8 @@ import net.minecraftforge.fml.network.NetworkRegistry;
import net.minecraftforge.fml.network.PacketDistributor;
import net.minecraftforge.fml.network.simple.SimpleChannel;
import java.util.function.Function;
public final class Network {
private static final String PROTOCOL_VERSION = "1";
@@ -28,149 +31,36 @@ public final class Network {
///////////////////////////////////////////////////////////////////
public static void initialize() {
INSTANCE.messageBuilder(ComputerTerminalOutputMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_CLIENT)
.encoder(ComputerTerminalOutputMessage::toBytes)
.decoder(ComputerTerminalOutputMessage::new)
.consumer(ComputerTerminalOutputMessage::handleMessage)
.add();
registerMessage(ComputerTerminalOutputMessage.class, ComputerTerminalOutputMessage::new, NetworkDirection.PLAY_TO_CLIENT);
registerMessage(ComputerTerminalInputMessage.class, ComputerTerminalInputMessage::new, NetworkDirection.PLAY_TO_SERVER);
registerMessage(ComputerRunStateMessage.class, ComputerRunStateMessage::new, NetworkDirection.PLAY_TO_CLIENT);
registerMessage(ComputerBusStateMessage.class, ComputerBusStateMessage::new, NetworkDirection.PLAY_TO_CLIENT);
registerMessage(ComputerBootErrorMessage.class, ComputerBootErrorMessage::new, NetworkDirection.PLAY_TO_CLIENT);
registerMessage(ComputerPowerMessage.class, ComputerPowerMessage::new, NetworkDirection.PLAY_TO_SERVER);
INSTANCE.messageBuilder(ComputerTerminalInputMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_SERVER)
.encoder(ComputerTerminalInputMessage::toBytes)
.decoder(ComputerTerminalInputMessage::new)
.consumer(ComputerTerminalInputMessage::handleMessage)
.add();
registerMessage(NetworkConnectorConnectionsMessage.class, NetworkConnectorConnectionsMessage::new, NetworkDirection.PLAY_TO_CLIENT);
INSTANCE.messageBuilder(ComputerRunStateMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_CLIENT)
.encoder(ComputerRunStateMessage::toBytes)
.decoder(ComputerRunStateMessage::new)
.consumer(ComputerRunStateMessage::handleMessage)
.add();
registerMessage(RobotTerminalOutputMessage.class, RobotTerminalOutputMessage::new, NetworkDirection.PLAY_TO_CLIENT);
registerMessage(RobotTerminalInputMessage.class, RobotTerminalInputMessage::new, NetworkDirection.PLAY_TO_SERVER);
registerMessage(RobotRunStateMessage.class, RobotRunStateMessage::new, NetworkDirection.PLAY_TO_CLIENT);
registerMessage(RobotBusStateMessage.class, RobotBusStateMessage::new, NetworkDirection.PLAY_TO_CLIENT);
registerMessage(RobotBootErrorMessage.class, RobotBootErrorMessage::new, NetworkDirection.PLAY_TO_CLIENT);
registerMessage(RobotPowerMessage.class, RobotPowerMessage::new, NetworkDirection.PLAY_TO_SERVER);
registerMessage(RobotInitializationRequestMessage.class, RobotInitializationRequestMessage::new, NetworkDirection.PLAY_TO_SERVER);
registerMessage(RobotInitializationMessage.class, RobotInitializationMessage::new, NetworkDirection.PLAY_TO_CLIENT);
INSTANCE.messageBuilder(ComputerBusStateMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_CLIENT)
.encoder(ComputerBusStateMessage::toBytes)
.decoder(ComputerBusStateMessage::new)
.consumer(ComputerBusStateMessage::handleMessage)
.add();
registerMessage(DiskDriveFloppyMessage.class, DiskDriveFloppyMessage::new, NetworkDirection.PLAY_TO_CLIENT);
INSTANCE.messageBuilder(ComputerBootErrorMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_CLIENT)
.encoder(ComputerBootErrorMessage::toBytes)
.decoder(ComputerBootErrorMessage::new)
.consumer(ComputerBootErrorMessage::handleMessage)
.add();
registerMessage(BusInterfaceNameMessage.ToClient.class, BusInterfaceNameMessage.ToClient::new, NetworkDirection.PLAY_TO_CLIENT);
registerMessage(BusInterfaceNameMessage.ToServer.class, BusInterfaceNameMessage.ToServer::new, NetworkDirection.PLAY_TO_SERVER);
INSTANCE.messageBuilder(ComputerPowerMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_SERVER)
.encoder(ComputerPowerMessage::toBytes)
.decoder(ComputerPowerMessage::new)
.consumer(ComputerPowerMessage::handleMessage)
.add();
registerMessage(ExportedFileMessage.class, ExportedFileMessage::new, NetworkDirection.PLAY_TO_CLIENT);
registerMessage(RequestImportedFileMessage.class, RequestImportedFileMessage::new, NetworkDirection.PLAY_TO_CLIENT);
registerMessage(ImportedFileMessage.class, ImportedFileMessage::new, NetworkDirection.PLAY_TO_SERVER);
registerMessage(ServerCanceledImportFileMessage.class, ServerCanceledImportFileMessage::new, NetworkDirection.PLAY_TO_CLIENT);
registerMessage(ClientCanceledImportFileMessage.class, ClientCanceledImportFileMessage::new, NetworkDirection.PLAY_TO_SERVER);
INSTANCE.messageBuilder(NetworkConnectorConnectionsMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_CLIENT)
.encoder(NetworkConnectorConnectionsMessage::toBytes)
.decoder(NetworkConnectorConnectionsMessage::new)
.consumer(NetworkConnectorConnectionsMessage::handleMessage)
.add();
INSTANCE.messageBuilder(RobotTerminalOutputMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_CLIENT)
.encoder(RobotTerminalOutputMessage::toBytes)
.decoder(RobotTerminalOutputMessage::new)
.consumer(RobotTerminalOutputMessage::handleMessage)
.add();
INSTANCE.messageBuilder(RobotTerminalInputMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_SERVER)
.encoder(RobotTerminalInputMessage::toBytes)
.decoder(RobotTerminalInputMessage::new)
.consumer(RobotTerminalInputMessage::handleMessage)
.add();
INSTANCE.messageBuilder(RobotRunStateMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_CLIENT)
.encoder(RobotRunStateMessage::toBytes)
.decoder(RobotRunStateMessage::new)
.consumer(RobotRunStateMessage::handleMessage)
.add();
INSTANCE.messageBuilder(RobotBusStateMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_CLIENT)
.encoder(RobotBusStateMessage::toBytes)
.decoder(RobotBusStateMessage::new)
.consumer(RobotBusStateMessage::handleMessage)
.add();
INSTANCE.messageBuilder(RobotBootErrorMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_CLIENT)
.encoder(RobotBootErrorMessage::toBytes)
.decoder(RobotBootErrorMessage::new)
.consumer(RobotBootErrorMessage::handleMessage)
.add();
INSTANCE.messageBuilder(RobotPowerMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_SERVER)
.encoder(RobotPowerMessage::toBytes)
.decoder(RobotPowerMessage::new)
.consumer(RobotPowerMessage::handleMessage)
.add();
INSTANCE.messageBuilder(RobotInitializationRequestMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_SERVER)
.encoder(RobotInitializationRequestMessage::toBytes)
.decoder(RobotInitializationRequestMessage::new)
.consumer(RobotInitializationRequestMessage::handleMessage)
.add();
INSTANCE.messageBuilder(RobotInitializationMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_CLIENT)
.encoder(RobotInitializationMessage::toBytes)
.decoder(RobotInitializationMessage::new)
.consumer(RobotInitializationMessage::handleMessage)
.add();
INSTANCE.messageBuilder(DiskDriveFloppyMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_CLIENT)
.encoder(DiskDriveFloppyMessage::toBytes)
.decoder(DiskDriveFloppyMessage::new)
.consumer(DiskDriveFloppyMessage::handleMessage)
.add();
INSTANCE.messageBuilder(BusInterfaceNameMessage.ToClient.class, getNextPacketId(), NetworkDirection.PLAY_TO_CLIENT)
.encoder(BusInterfaceNameMessage::toBytes)
.decoder(BusInterfaceNameMessage.ToClient::new)
.consumer(BusInterfaceNameMessage::handleMessageClient)
.add();
INSTANCE.messageBuilder(BusInterfaceNameMessage.ToServer.class, getNextPacketId(), NetworkDirection.PLAY_TO_SERVER)
.encoder(BusInterfaceNameMessage::toBytes)
.decoder(BusInterfaceNameMessage.ToServer::new)
.consumer(BusInterfaceNameMessage::handleMessageServer)
.add();
INSTANCE.messageBuilder(ExportedFileMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_CLIENT)
.encoder(ExportedFileMessage::toBytes)
.decoder(ExportedFileMessage::new)
.consumer(ExportedFileMessage::handleMessage)
.add();
INSTANCE.messageBuilder(RequestImportedFileMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_CLIENT)
.encoder(RequestImportedFileMessage::toBytes)
.decoder(RequestImportedFileMessage::new)
.consumer(RequestImportedFileMessage::handleMessage)
.add();
INSTANCE.messageBuilder(ImportedFileMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_SERVER)
.encoder(ImportedFileMessage::toBytes)
.decoder(ImportedFileMessage::new)
.consumer(ImportedFileMessage::handleMessage)
.add();
INSTANCE.messageBuilder(ServerCanceledImportFileMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_CLIENT)
.encoder(ServerCanceledImportFileMessage::toBytes)
.decoder(ServerCanceledImportFileMessage::new)
.consumer(ServerCanceledImportFileMessage::handleMessage)
.add();
INSTANCE.messageBuilder(ClientCanceledImportFileMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_SERVER)
.encoder(ClientCanceledImportFileMessage::toBytes)
.decoder(ClientCanceledImportFileMessage::new)
.consumer(ClientCanceledImportFileMessage::handleMessage)
.add();
INSTANCE.messageBuilder(BusCableFacadeMessage.class, getNextPacketId(), NetworkDirection.PLAY_TO_CLIENT)
.encoder(BusCableFacadeMessage::toBytes)
.decoder(BusCableFacadeMessage::new)
.consumer(BusCableFacadeMessage::handleMessage)
.add();
registerMessage(BusCableFacadeMessage.class, BusCableFacadeMessage::new, NetworkDirection.PLAY_TO_CLIENT);
}
public static <T> void sendToClientsTrackingChunk(final T message, final Chunk chunk) {
@@ -188,6 +78,14 @@ public final class Network {
///////////////////////////////////////////////////////////////////
private static <T extends AbstractMessage> void registerMessage(final Class<T> type, final Function<PacketBuffer, T> decoder, final NetworkDirection direction) {
INSTANCE.messageBuilder(type, getNextPacketId(), direction)
.encoder(AbstractMessage::toBytes)
.decoder(decoder)
.consumer(AbstractMessage::handleMessage)
.add();
}
private static int getNextPacketId() {
return nextPacketId++;
}

44
src/main/java/li/cil/oc2/common/network/message/AbstractMessage.java Normal file
View File

@@ -0,0 +1,44 @@
package li.cil.oc2.common.network.message;
import net.minecraft.network.PacketBuffer;
import net.minecraftforge.fml.network.NetworkEvent;
import org.apache.commons.lang3.NotImplementedException;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.function.Supplier;
public abstract class AbstractMessage {
protected static final Logger LOGGER = LogManager.getLogger();
///////////////////////////////////////////////////////////////////
protected AbstractMessage() {
}
protected AbstractMessage(final PacketBuffer buffer) {
fromBytes(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final AbstractMessage message, final Supplier<NetworkEvent.Context> contextSupplier) {
message.handleMessage(contextSupplier);
return true;
}
public abstract void fromBytes(final PacketBuffer buffer);
public abstract void toBytes(final PacketBuffer buffer);
///////////////////////////////////////////////////////////////////
protected void handleMessage(final Supplier<NetworkEvent.Context> contextSupplier) {
final NetworkEvent.Context context = contextSupplier.get();
context.enqueueWork(() -> handleMessage(context));
}
protected void handleMessage(final NetworkEvent.Context context) {
throw new NotImplementedException("Message implements neither asynchronous nor synchronous handleMessage() method.");
}
}

12
src/main/java/li/cil/oc2/common/network/message/AbstractTerminalBlockMessage.java
View File

@@ -6,7 +6,7 @@ import net.minecraft.util.math.BlockPos;
import java.nio.ByteBuffer;
public abstract class AbstractTerminalBlockMessage {
public abstract class AbstractTerminalBlockMessage extends AbstractMessage {
protected BlockPos pos;
protected byte[] data;
@@ -18,18 +18,20 @@ public abstract class AbstractTerminalBlockMessage {
}
protected AbstractTerminalBlockMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
@Override
public void fromBytes(final PacketBuffer buffer) {
pos = buffer.readBlockPos();
data = buffer.readByteArray();
}
public static void toBytes(final AbstractTerminalBlockMessage message, final PacketBuffer buffer) {
buffer.writeBlockPos(message.pos);
buffer.writeByteArray(message.data);
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeBlockPos(pos);
buffer.writeByteArray(data);
}
}

12
src/main/java/li/cil/oc2/common/network/message/AbstractTerminalEntityMessage.java
View File

@@ -5,7 +5,7 @@ import net.minecraft.network.PacketBuffer;
import java.nio.ByteBuffer;
public abstract class AbstractTerminalEntityMessage {
public abstract class AbstractTerminalEntityMessage extends AbstractMessage {
protected int entityId;
protected byte[] data;
@@ -17,18 +17,20 @@ public abstract class AbstractTerminalEntityMessage {
}
protected AbstractTerminalEntityMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
@Override
public void fromBytes(final PacketBuffer buffer) {
entityId = buffer.readVarInt();
data = buffer.readByteArray();
}
public static void toBytes(final AbstractTerminalEntityMessage message, final PacketBuffer buffer) {
buffer.writeVarInt(message.entityId);
buffer.writeByteArray(message.data);
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeVarInt(entityId);
buffer.writeByteArray(data);
}
}

30
src/main/java/li/cil/oc2/common/network/message/BusCableFacadeMessage.java
View File

@@ -7,36 +7,40 @@ import net.minecraft.network.PacketBuffer;
import net.minecraft.util.math.BlockPos;
import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Supplier;
public final class BusCableFacadeMessage {
public final class BusCableFacadeMessage extends AbstractMessage {
private BlockPos pos;
private ItemStack stack;
///////////////////////////////////////////////////////////////////
public BusCableFacadeMessage(final BlockPos pos, final ItemStack stack) {
this.pos = pos;
this.stack = stack;
}
public BusCableFacadeMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final BusCableFacadeMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withClientTileEntityAt(message.pos, BusCableTileEntity.class,
(tileEntity) -> tileEntity.setFacade(message.stack)));
return true;
}
@Override
public void fromBytes(final PacketBuffer buffer) {
pos = buffer.readBlockPos();
stack = buffer.readItem();
}
public static void toBytes(final BusCableFacadeMessage message, final PacketBuffer buffer) {
buffer.writeBlockPos(message.pos);
buffer.writeItem(message.stack);
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeBlockPos(pos);
buffer.writeItem(stack);
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withClientTileEntityAt(pos, BusCableTileEntity.class,
(tileEntity) -> tileEntity.setFacade(stack));
}
}

52
src/main/java/li/cil/oc2/common/network/message/BusInterfaceNameMessage.java
View File

@@ -5,15 +5,12 @@ import li.cil.oc2.common.tileentity.BusCableTileEntity;
import net.minecraft.network.PacketBuffer;
import net.minecraft.util.Direction;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.vector.Vector3d;
import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Supplier;
public abstract class BusInterfaceNameMessage {
private BlockPos pos;
private Direction side;
private String value;
public abstract class BusInterfaceNameMessage extends AbstractMessage {
protected BlockPos pos;
protected Direction side;
protected String value;
///////////////////////////////////////////////////////////////////
@@ -24,38 +21,23 @@ public abstract class BusInterfaceNameMessage {
}
protected BusInterfaceNameMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessageClient(final BusInterfaceNameMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withClientTileEntityAt(message.pos, BusCableTileEntity.class,
(tileEntity) -> tileEntity.setInterfaceName(message.side, message.value)));
return true;
}
public static boolean handleMessageServer(final BusInterfaceNameMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withServerTileEntityAt(context, message.pos, BusCableTileEntity.class,
(tileEntity) -> {
final Vector3d busCableCenter = Vector3d.atCenterOf(tileEntity.getBlockPos());
if (context.get().getSender().distanceToSqr(busCableCenter) <= 8 * 8) {
tileEntity.setInterfaceName(message.side, message.value);
}
}));
return true;
}
@Override
public void fromBytes(final PacketBuffer buffer) {
pos = buffer.readBlockPos();
side = buffer.readEnum(Direction.class);
value = buffer.readUtf(32);
}
public static void toBytes(final BusInterfaceNameMessage message, final PacketBuffer buffer) {
buffer.writeBlockPos(message.pos);
buffer.writeEnum(message.side);
buffer.writeUtf(message.value, 32);
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeBlockPos(pos);
buffer.writeEnum(side);
buffer.writeUtf(value, 32);
}
///////////////////////////////////////////////////////////////////
@@ -68,6 +50,12 @@ public abstract class BusInterfaceNameMessage {
public ToClient(final PacketBuffer buffer) {
super(buffer);
}
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withClientTileEntityAt(pos, BusCableTileEntity.class,
(tileEntity) -> tileEntity.setInterfaceName(side, value));
}
}
public static final class ToServer extends BusInterfaceNameMessage {
@@ -78,5 +66,11 @@ public abstract class BusInterfaceNameMessage {
public ToServer(final PacketBuffer buffer) {
super(buffer);
}
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withNearbyServerTileEntityAt(context, pos, BusCableTileEntity.class,
(tileEntity) -> tileEntity.setInterfaceName(side, value));
}
}
}

26
src/main/java/li/cil/oc2/common/network/message/ClientCanceledImportFileMessage.java
View File

@@ -6,7 +6,7 @@ import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Supplier;
public final class ClientCanceledImportFileMessage {
public final class ClientCanceledImportFileMessage extends AbstractMessage {
private int id;
///////////////////////////////////////////////////////////////////
@@ -16,21 +16,25 @@ public final class ClientCanceledImportFileMessage {
}
public ClientCanceledImportFileMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final ClientCanceledImportFileMessage message, final Supplier<NetworkEvent.Context> context) {
FileImportExportCardItemDevice.cancelImport(context.get().getSender(), message.id);
return true;
}
public static void toBytes(final ClientCanceledImportFileMessage message, final PacketBuffer buffer) {
buffer.writeVarInt(message.id);
}
@Override
public void fromBytes(final PacketBuffer buffer) {
id = buffer.readVarInt();
}
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeVarInt(id);
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final Supplier<NetworkEvent.Context> context) {
FileImportExportCardItemDevice.cancelImport(context.get().getSender(), id);
}
}

28
src/main/java/li/cil/oc2/common/network/message/ComputerBootErrorMessage.java
View File

@@ -7,9 +7,7 @@ import net.minecraft.util.math.BlockPos;
import net.minecraft.util.text.ITextComponent;
import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Supplier;
public final class ComputerBootErrorMessage {
public final class ComputerBootErrorMessage extends AbstractMessage {
private BlockPos pos;
private ITextComponent value;
@@ -21,24 +19,28 @@ public final class ComputerBootErrorMessage {
}
public ComputerBootErrorMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final ComputerBootErrorMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withClientTileEntityAt(message.pos, ComputerTileEntity.class,
(tileEntity) -> tileEntity.getVirtualMachine().setBootErrorClient(message.value)));
return true;
}
@Override
public void fromBytes(final PacketBuffer buffer) {
pos = buffer.readBlockPos();
value = buffer.readComponent();
}
public static void toBytes(final ComputerBootErrorMessage message, final PacketBuffer buffer) {
buffer.writeBlockPos(message.pos);
buffer.writeComponent(message.value);
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeBlockPos(pos);
buffer.writeComponent(value);
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withClientTileEntityAt(pos, ComputerTileEntity.class,
(tileEntity) -> tileEntity.getVirtualMachine().setBootErrorClient(value));
}
}

28
src/main/java/li/cil/oc2/common/network/message/ComputerBusStateMessage.java
View File

@@ -7,9 +7,7 @@ import net.minecraft.network.PacketBuffer;
import net.minecraft.util.math.BlockPos;
import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Supplier;
public final class ComputerBusStateMessage {
public final class ComputerBusStateMessage extends AbstractMessage {
private BlockPos pos;
private CommonDeviceBusController.BusState value;
@@ -21,24 +19,28 @@ public final class ComputerBusStateMessage {
}
public ComputerBusStateMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final ComputerBusStateMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withClientTileEntityAt(message.pos, ComputerTileEntity.class,
(tileEntity) -> tileEntity.getVirtualMachine().setBusStateClient(message.value)));
return true;
}
@Override
public void fromBytes(final PacketBuffer buffer) {
pos = buffer.readBlockPos();
value = buffer.readEnum(CommonDeviceBusController.BusState.class);
}
public static void toBytes(final ComputerBusStateMessage message, final PacketBuffer buffer) {
buffer.writeBlockPos(message.pos);
buffer.writeEnum(message.value);
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeBlockPos(pos);
buffer.writeEnum(value);
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withClientTileEntityAt(pos, ComputerTileEntity.class,
(tileEntity) -> tileEntity.getVirtualMachine().setBusStateClient(value));
}
}

44
src/main/java/li/cil/oc2/common/network/message/ComputerPowerMessage.java
View File

@@ -2,14 +2,11 @@ package li.cil.oc2.common.network.message;
import li.cil.oc2.common.network.MessageUtils;
import li.cil.oc2.common.tileentity.ComputerTileEntity;
import net.minecraft.entity.player.ServerPlayerEntity;
import net.minecraft.network.PacketBuffer;
import net.minecraft.util.math.BlockPos;
import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Supplier;
public final class ComputerPowerMessage {
public final class ComputerPowerMessage extends AbstractMessage {
private BlockPos pos;
private boolean power;
@@ -21,33 +18,34 @@ public final class ComputerPowerMessage {
}
public ComputerPowerMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final ComputerPowerMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withServerTileEntityAt(context, message.pos, ComputerTileEntity.class,
(computer) -> {
final ServerPlayerEntity player = context.get().getSender();
if (player != null && computer.getBlockPos().closerThan(player.position(), 8)) {
if (message.power) {
computer.start();
} else {
computer.stop();
}
}
}));
return true;
}
@Override
public void fromBytes(final PacketBuffer buffer) {
pos = buffer.readBlockPos();
power = buffer.readBoolean();
}
public static void toBytes(final ComputerPowerMessage message, final PacketBuffer buffer) {
buffer.writeBlockPos(message.pos);
buffer.writeBoolean(message.power);
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeBlockPos(pos);
buffer.writeBoolean(power);
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withNearbyServerTileEntityAt(context, pos, ComputerTileEntity.class,
(computer) -> {
if (power) {
computer.start();
} else {
computer.stop();
}
});
}
}

28
src/main/java/li/cil/oc2/common/network/message/ComputerRunStateMessage.java
View File

@@ -7,9 +7,7 @@ import net.minecraft.network.PacketBuffer;
import net.minecraft.util.math.BlockPos;
import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Supplier;
public final class ComputerRunStateMessage {
public final class ComputerRunStateMessage extends AbstractMessage {
private BlockPos pos;
private VMRunState value;
@@ -21,24 +19,28 @@ public final class ComputerRunStateMessage {
}
public ComputerRunStateMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final ComputerRunStateMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withClientTileEntityAt(message.pos, ComputerTileEntity.class,
(tileEntity) -> tileEntity.getVirtualMachine().setRunStateClient(message.value)));
return true;
}
@Override
public void fromBytes(final PacketBuffer buffer) {
pos = buffer.readBlockPos();
value = buffer.readEnum(VMRunState.class);
}
public static void toBytes(final ComputerRunStateMessage message, final PacketBuffer buffer) {
buffer.writeBlockPos(message.pos);
buffer.writeEnum(message.value);
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeBlockPos(pos);
buffer.writeEnum(value);
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withClientTileEntityAt(pos, ComputerTileEntity.class,
(tileEntity) -> tileEntity.getVirtualMachine().setRunStateClient(value));
}
}

9
src/main/java/li/cil/oc2/common/network/message/ComputerTerminalInputMessage.java
View File

@@ -6,7 +6,6 @@ import net.minecraft.network.PacketBuffer;
import net.minecraftforge.fml.network.NetworkEvent;
import java.nio.ByteBuffer;
import java.util.function.Supplier;
public final class ComputerTerminalInputMessage extends AbstractTerminalBlockMessage {
public ComputerTerminalInputMessage(final ComputerTileEntity tileEntity, final ByteBuffer data) {
@@ -19,9 +18,9 @@ public final class ComputerTerminalInputMessage extends AbstractTerminalBlockMes
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final AbstractTerminalBlockMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withServerTileEntityAt(context, message.pos, ComputerTileEntity.class,
(tileEntity) -> tileEntity.getTerminal().putInput(ByteBuffer.wrap(message.data))));
return true;
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withNearbyServerTileEntityAt(context, pos, ComputerTileEntity.class,
(tileEntity) -> tileEntity.getTerminal().putInput(ByteBuffer.wrap(data)));
}
}

9
src/main/java/li/cil/oc2/common/network/message/ComputerTerminalOutputMessage.java
View File

@@ -6,7 +6,6 @@ import net.minecraft.network.PacketBuffer;
import net.minecraftforge.fml.network.NetworkEvent;
import java.nio.ByteBuffer;
import java.util.function.Supplier;
public final class ComputerTerminalOutputMessage extends AbstractTerminalBlockMessage {
public ComputerTerminalOutputMessage(final ComputerTileEntity tileEntity, final ByteBuffer data) {
@@ -19,9 +18,9 @@ public final class ComputerTerminalOutputMessage extends AbstractTerminalBlockMe
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final AbstractTerminalBlockMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withClientTileEntityAt(message.pos, ComputerTileEntity.class,
tileEntity -> tileEntity.getTerminal().putOutput(ByteBuffer.wrap(message.data))));
return true;
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withClientTileEntityAt(pos, ComputerTileEntity.class,
tileEntity -> tileEntity.getTerminal().putOutput(ByteBuffer.wrap(data)));
}
}

28
src/main/java/li/cil/oc2/common/network/message/DiskDriveFloppyMessage.java
View File

@@ -8,9 +8,7 @@ import net.minecraft.network.PacketBuffer;
import net.minecraft.util.math.BlockPos;
import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Supplier;
public final class DiskDriveFloppyMessage {
public final class DiskDriveFloppyMessage extends AbstractMessage {
private BlockPos pos;
private CompoundNBT data;
@@ -22,24 +20,28 @@ public final class DiskDriveFloppyMessage {
}
public DiskDriveFloppyMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final DiskDriveFloppyMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withClientTileEntityAt(message.pos, DiskDriveTileEntity.class,
(diskDrive) -> diskDrive.setFloppyClient(ItemStack.of(message.data))));
return true;
}
@Override
public void fromBytes(final PacketBuffer buffer) {
pos = buffer.readBlockPos();
data = buffer.readNbt();
}
public static void toBytes(final DiskDriveFloppyMessage message, final PacketBuffer buffer) {
buffer.writeBlockPos(message.pos);
buffer.writeNbt(message.data);
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeBlockPos(pos);
buffer.writeNbt(data);
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withClientTileEntityAt(pos, DiskDriveTileEntity.class,
(diskDrive) -> diskDrive.setFloppyClient(ItemStack.of(data)));
}
}

41
src/main/java/li/cil/oc2/common/network/message/ExportedFileMessage.java
View File

@@ -8,9 +8,8 @@ import org.apache.logging.log4j.Logger;
import java.io.IOException;
import java.nio.file.Files;
import java.util.function.Supplier;
public final class ExportedFileMessage {
public final class ExportedFileMessage extends AbstractMessage {
private static final Logger LOGGER = LogManager.getLogger();
///////////////////////////////////////////////////////////////////
@@ -26,30 +25,32 @@ public final class ExportedFileMessage {
}
public ExportedFileMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final ExportedFileMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> FileChooserScreen.openFileChooserForSave(message.name, path -> {
try {
Files.write(path, message.data);
} catch (final IOException e) {
LOGGER.error(e);
}
}));
return true;
}
public static void toBytes(final ExportedFileMessage message, final PacketBuffer buffer) {
buffer.writeUtf(message.name);
buffer.writeByteArray(message.data);
}
@Override
public void fromBytes(final PacketBuffer buffer) {
name = buffer.readUtf();
data = buffer.readByteArray();
}
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeUtf(name);
buffer.writeByteArray(data);
}
///////////////////////////////////////////////////////////////////
protected void handleMessage(final NetworkEvent.Context context) {
FileChooserScreen.openFileChooserForSave(name, path -> {
try {
Files.write(path, data);
} catch (final IOException e) {
LOGGER.error(e);
}
});
}
}

30
src/main/java/li/cil/oc2/common/network/message/ImportedFileMessage.java
View File

@@ -6,7 +6,7 @@ import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Supplier;
public final class ImportedFileMessage {
public final class ImportedFileMessage extends AbstractMessage {
private static final int MAX_NAME_LENGTH = 256;
///////////////////////////////////////////////////////////////////
@@ -24,25 +24,29 @@ public final class ImportedFileMessage {
}
public ImportedFileMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final ImportedFileMessage message, final Supplier<NetworkEvent.Context> context) {
FileImportExportCardItemDevice.setImportedFile(message.id, message.name, message.data);
return true;
}
public static void toBytes(final ImportedFileMessage message, final PacketBuffer buffer) {
buffer.writeVarInt(message.id);
buffer.writeUtf(message.name, MAX_NAME_LENGTH);
buffer.writeByteArray(message.data);
}
@Override
public void fromBytes(final PacketBuffer buffer) {
id = buffer.readVarInt();
name = buffer.readUtf(MAX_NAME_LENGTH);
data = buffer.readByteArray();
}
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeVarInt(id);
buffer.writeUtf(name, MAX_NAME_LENGTH);
buffer.writeByteArray(data);
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final Supplier<NetworkEvent.Context> context) {
FileImportExportCardItemDevice.setImportedFile(id, name, data);
}
}

29
src/main/java/li/cil/oc2/common/network/message/NetworkConnectorConnectionsMessage.java
View File

@@ -7,9 +7,8 @@ import net.minecraft.util.math.BlockPos;
import net.minecraftforge.fml.network.NetworkEvent;
import java.util.ArrayList;
import java.util.function.Supplier;
public final class NetworkConnectorConnectionsMessage {
public final class NetworkConnectorConnectionsMessage extends AbstractMessage {
private BlockPos pos;
private ArrayList<BlockPos> connectedPositions;
@@ -21,17 +20,12 @@ public final class NetworkConnectorConnectionsMessage {
}
public NetworkConnectorConnectionsMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final NetworkConnectorConnectionsMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withClientTileEntityAt(message.pos, NetworkConnectorTileEntity.class,
(tileEntity) -> tileEntity.setConnectedPositionsClient(message.connectedPositions)));
return true;
}
@Override
public void fromBytes(final PacketBuffer buffer) {
pos = buffer.readBlockPos();
connectedPositions = new ArrayList<>();
@@ -42,11 +36,20 @@ public final class NetworkConnectorConnectionsMessage {
}
}
public static void toBytes(final NetworkConnectorConnectionsMessage message, final PacketBuffer buffer) {
buffer.writeBlockPos(message.pos);
buffer.writeVarInt(message.connectedPositions.size());
for (final BlockPos pos : message.connectedPositions) {
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeBlockPos(pos);
buffer.writeVarInt(connectedPositions.size());
for (final BlockPos pos : connectedPositions) {
buffer.writeBlockPos(pos);
}
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withClientTileEntityAt(pos, NetworkConnectorTileEntity.class,
(tileEntity) -> tileEntity.setConnectedPositionsClient(connectedPositions));
}
}

40
src/main/java/li/cil/oc2/common/network/message/RequestImportedFileMessage.java
View File

@@ -14,11 +14,10 @@ import org.apache.logging.log4j.Logger;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.function.Supplier;
import static li.cil.oc2.common.util.TranslationUtils.text;
public final class RequestImportedFileMessage {
public final class RequestImportedFileMessage extends AbstractMessage {
private static final Logger LOGGER = LogManager.getLogger();
private static final TranslationTextComponent FILE_TOO_LARGE_TEXT = text("message.{mod}.import_file.file_too_large");
@@ -33,24 +32,37 @@ public final class RequestImportedFileMessage {
}
public RequestImportedFileMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final RequestImportedFileMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> FileChooserScreen.openFileChooserForLoad(new FileChooserScreen.FileChooserCallback() {
@Override
public void fromBytes(final PacketBuffer buffer) {
id = buffer.readVarInt();
}
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeVarInt(id);
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final NetworkEvent.Context context) {
FileChooserScreen.openFileChooserForLoad(new FileChooserScreen.FileChooserCallback() {
@Override
public void onFileSelected(final Path path) {
try {
final String fileName = path.getFileName().toString();
final byte[] data = Files.readAllBytes(path);
if (data.length > FileImportExportCardItemDevice.MAX_TRANSFERRED_FILE_SIZE) {
Network.INSTANCE.sendToServer(new ClientCanceledImportFileMessage(message.id));
Network.INSTANCE.sendToServer(new ClientCanceledImportFileMessage(id));
Minecraft.getInstance().player.displayClientMessage(FILE_TOO_LARGE_TEXT
.withStyle(s -> s.withColor(Color.fromRgb(0xFFA0A0))), false);
} else {
Network.INSTANCE.sendToServer(new ImportedFileMessage(message.id, fileName, data));
Network.INSTANCE.sendToServer(new ImportedFileMessage(id, fileName, data));
}
} catch (final IOException e) {
LOGGER.error(e);
@@ -59,18 +71,8 @@ public final class RequestImportedFileMessage {
@Override
public void onCanceled() {
Network.INSTANCE.sendToServer(new ClientCanceledImportFileMessage(message.id));
Network.INSTANCE.sendToServer(new ClientCanceledImportFileMessage(id));
}
}));
return true;
}
public static void toBytes(final RequestImportedFileMessage message, final PacketBuffer buffer) {
buffer.writeVarInt(message.id);
}
public void fromBytes(final PacketBuffer buffer) {
id = buffer.readVarInt();
});
}
}

28
src/main/java/li/cil/oc2/common/network/message/RobotBootErrorMessage.java
View File

@@ -6,9 +6,7 @@ import net.minecraft.network.PacketBuffer;
import net.minecraft.util.text.ITextComponent;
import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Supplier;
public final class RobotBootErrorMessage {
public final class RobotBootErrorMessage extends AbstractMessage {
private int entityId;
private ITextComponent value;
@@ -20,24 +18,28 @@ public final class RobotBootErrorMessage {
}
public RobotBootErrorMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final RobotBootErrorMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withClientEntity(message.entityId, RobotEntity.class,
(robot) -> robot.getVirtualMachine().setBootErrorClient(message.value)));
return true;
}
@Override
public void fromBytes(final PacketBuffer buffer) {
entityId = buffer.readVarInt();
value = buffer.readComponent();
}
public static void toBytes(final RobotBootErrorMessage message, final PacketBuffer buffer) {
buffer.writeVarInt(message.entityId);
buffer.writeComponent(message.value);
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeVarInt(entityId);
buffer.writeComponent(value);
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withClientEntity(entityId, RobotEntity.class,
(robot) -> robot.getVirtualMachine().setBootErrorClient(value));
}
}

28
src/main/java/li/cil/oc2/common/network/message/RobotBusStateMessage.java
View File

@@ -6,9 +6,7 @@ import li.cil.oc2.common.network.MessageUtils;
import net.minecraft.network.PacketBuffer;
import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Supplier;
public final class RobotBusStateMessage {
public final class RobotBusStateMessage extends AbstractMessage {
private int entityId;
private CommonDeviceBusController.BusState value;
@@ -20,24 +18,28 @@ public final class RobotBusStateMessage {
}
public RobotBusStateMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final RobotBusStateMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withClientEntity(message.entityId, RobotEntity.class,
(robot) -> robot.getVirtualMachine().setBusStateClient(message.value)));
return true;
}
@Override
public void fromBytes(final PacketBuffer buffer) {
entityId = buffer.readVarInt();
value = buffer.readEnum(CommonDeviceBusController.BusState.class);
}
public static void toBytes(final RobotBusStateMessage message, final PacketBuffer buffer) {
buffer.writeVarInt(message.entityId);
buffer.writeEnum(message.value);
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeVarInt(entityId);
buffer.writeEnum(value);
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withClientEntity(entityId, RobotEntity.class,
(robot) -> robot.getVirtualMachine().setBusStateClient(value));
}
}

44
src/main/java/li/cil/oc2/common/network/message/RobotInitializationMessage.java
View File

@@ -10,9 +10,7 @@ import net.minecraft.network.PacketBuffer;
import net.minecraft.util.text.ITextComponent;
import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Supplier;
public final class RobotInitializationMessage {
public final class RobotInitializationMessage extends AbstractMessage {
private int entityId;
private CommonDeviceBusController.BusState busState;
private VMRunState runState;
@@ -30,22 +28,12 @@ public final class RobotInitializationMessage {
}
public RobotInitializationMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final RobotInitializationMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withClientEntity(message.entityId, RobotEntity.class,
(robot) -> {
robot.getVirtualMachine().setBusStateClient(message.busState);
robot.getVirtualMachine().setRunStateClient(message.runState);
robot.getVirtualMachine().setBootErrorClient(message.bootError);
NBTSerialization.deserialize(message.terminal, robot.getTerminal());
}));
return true;
}
@Override
public void fromBytes(final PacketBuffer buffer) {
entityId = buffer.readVarInt();
busState = buffer.readEnum(CommonDeviceBusController.BusState.class);
@@ -54,11 +42,25 @@ public final class RobotInitializationMessage {
terminal = buffer.readNbt();
}
public static void toBytes(final RobotInitializationMessage message, final PacketBuffer buffer) {
buffer.writeVarInt(message.entityId);
buffer.writeEnum(message.busState);
buffer.writeEnum(message.runState);
buffer.writeComponent(message.bootError);
buffer.writeNbt(message.terminal);
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeVarInt(entityId);
buffer.writeEnum(busState);
buffer.writeEnum(runState);
buffer.writeComponent(bootError);
buffer.writeNbt(terminal);
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withClientEntity(entityId, RobotEntity.class,
(robot) -> {
robot.getVirtualMachine().setBusStateClient(busState);
robot.getVirtualMachine().setRunStateClient(runState);
robot.getVirtualMachine().setBootErrorClient(bootError);
NBTSerialization.deserialize(terminal, robot.getTerminal());
});
}
}

26
src/main/java/li/cil/oc2/common/network/message/RobotInitializationRequestMessage.java
View File

@@ -6,9 +6,7 @@ import li.cil.oc2.common.network.Network;
import net.minecraft.network.PacketBuffer;
import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Supplier;
public final class RobotInitializationRequestMessage {
public final class RobotInitializationRequestMessage extends AbstractMessage {
private int entityId;
///////////////////////////////////////////////////////////////////
@@ -18,22 +16,26 @@ public final class RobotInitializationRequestMessage {
}
public RobotInitializationRequestMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final RobotInitializationRequestMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withServerEntity(context, message.entityId, RobotEntity.class,
(robot) -> Network.INSTANCE.reply(new RobotInitializationMessage(robot), context.get())));
return true;
}
@Override
public void fromBytes(final PacketBuffer buffer) {
entityId = buffer.readVarInt();
}
public static void toBytes(final RobotInitializationRequestMessage message, final PacketBuffer buffer) {
buffer.writeVarInt(message.entityId);
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeVarInt(entityId);
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withServerEntity(context, entityId, RobotEntity.class,
(robot) -> Network.INSTANCE.reply(new RobotInitializationMessage(robot), context));
}
}

44
src/main/java/li/cil/oc2/common/network/message/RobotPowerMessage.java
View File

@@ -2,13 +2,10 @@ package li.cil.oc2.common.network.message;
import li.cil.oc2.common.entity.RobotEntity;
import li.cil.oc2.common.network.MessageUtils;
import net.minecraft.entity.player.ServerPlayerEntity;
import net.minecraft.network.PacketBuffer;
import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Supplier;
public final class RobotPowerMessage {
public final class RobotPowerMessage extends AbstractMessage {
private int entityId;
private boolean power;
@@ -20,33 +17,34 @@ public final class RobotPowerMessage {
}
public RobotPowerMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final RobotPowerMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withServerEntity(context, message.entityId, RobotEntity.class,
(robot) -> {
final ServerPlayerEntity player = context.get().getSender();
if (player != null && robot.closerThan(player, 8)) {
if (message.power) {
robot.start();
} else {
robot.stop();
}
}
}));
return true;
}
@Override
public void fromBytes(final PacketBuffer buffer) {
entityId = buffer.readVarInt();
power = buffer.readBoolean();
}
public static void toBytes(final RobotPowerMessage message, final PacketBuffer buffer) {
buffer.writeVarInt(message.entityId);
buffer.writeBoolean(message.power);
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeVarInt(entityId);
buffer.writeBoolean(power);
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withNearbyServerEntity(context, entityId, RobotEntity.class,
(robot) -> {
if (power) {
robot.start();
} else {
robot.stop();
}
});
}
}

28
src/main/java/li/cil/oc2/common/network/message/RobotRunStateMessage.java
View File

@@ -6,9 +6,7 @@ import li.cil.oc2.common.vm.VMRunState;
import net.minecraft.network.PacketBuffer;
import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Supplier;
public final class RobotRunStateMessage {
public final class RobotRunStateMessage extends AbstractMessage {
private int entityId;
private VMRunState value;
@@ -20,24 +18,28 @@ public final class RobotRunStateMessage {
}
public RobotRunStateMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final RobotRunStateMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withClientEntity(message.entityId, RobotEntity.class,
(robot) -> robot.getVirtualMachine().setRunStateClient(message.value)));
return true;
}
@Override
public void fromBytes(final PacketBuffer buffer) {
entityId = buffer.readVarInt();
value = buffer.readEnum(VMRunState.class);
}
public static void toBytes(final RobotRunStateMessage message, final PacketBuffer buffer) {
buffer.writeVarInt(message.entityId);
buffer.writeEnum(message.value);
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeVarInt(entityId);
buffer.writeEnum(value);
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withClientEntity(entityId, RobotEntity.class,
(robot) -> robot.getVirtualMachine().setRunStateClient(value));
}
}

9
src/main/java/li/cil/oc2/common/network/message/RobotTerminalInputMessage.java
View File

@@ -6,7 +6,6 @@ import net.minecraft.network.PacketBuffer;
import net.minecraftforge.fml.network.NetworkEvent;
import java.nio.ByteBuffer;
import java.util.function.Supplier;
public final class RobotTerminalInputMessage extends AbstractTerminalEntityMessage {
public RobotTerminalInputMessage(final RobotEntity robot, final ByteBuffer data) {
@@ -19,9 +18,9 @@ public final class RobotTerminalInputMessage extends AbstractTerminalEntityMessa
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final AbstractTerminalEntityMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withServerEntity(context, message.entityId, RobotEntity.class,
(tileEntity) -> tileEntity.getTerminal().putInput(ByteBuffer.wrap(message.data))));
return true;
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withNearbyServerEntity(context, entityId, RobotEntity.class,
(tileEntity) -> tileEntity.getTerminal().putInput(ByteBuffer.wrap(data)));
}
}

9
src/main/java/li/cil/oc2/common/network/message/RobotTerminalOutputMessage.java
View File

@@ -6,7 +6,6 @@ import net.minecraft.network.PacketBuffer;
import net.minecraftforge.fml.network.NetworkEvent;
import java.nio.ByteBuffer;
import java.util.function.Supplier;
public final class RobotTerminalOutputMessage extends AbstractTerminalEntityMessage {
public RobotTerminalOutputMessage(final RobotEntity robot, final ByteBuffer data) {
@@ -19,9 +18,9 @@ public final class RobotTerminalOutputMessage extends AbstractTerminalEntityMess
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final AbstractTerminalEntityMessage message, final Supplier<NetworkEvent.Context> context) {
context.get().enqueueWork(() -> MessageUtils.withClientEntity(message.entityId, RobotEntity.class,
robot -> robot.getTerminal().putOutput(ByteBuffer.wrap(message.data))));
return true;
@Override
protected void handleMessage(final NetworkEvent.Context context) {
MessageUtils.withClientEntity(entityId, RobotEntity.class,
robot -> robot.getTerminal().putOutput(ByteBuffer.wrap(data)));
}
}

26
src/main/java/li/cil/oc2/common/network/message/ServerCanceledImportFileMessage.java
View File

@@ -6,7 +6,7 @@ import net.minecraftforge.fml.network.NetworkEvent;
import java.util.function.Supplier;
public final class ServerCanceledImportFileMessage {
public final class ServerCanceledImportFileMessage extends AbstractMessage {
private int id;
///////////////////////////////////////////////////////////////////
@@ -16,21 +16,25 @@ public final class ServerCanceledImportFileMessage {
}
public ServerCanceledImportFileMessage(final PacketBuffer buffer) {
fromBytes(buffer);
super(buffer);
}
///////////////////////////////////////////////////////////////////
public static boolean handleMessage(final ServerCanceledImportFileMessage message, final Supplier<NetworkEvent.Context> context) {
FileImportExportCardItemDevice.cancelImport(context.get().getSender(), message.id);
return true;
}
public static void toBytes(final ServerCanceledImportFileMessage message, final PacketBuffer buffer) {
buffer.writeVarInt(message.id);
}
@Override
public void fromBytes(final PacketBuffer buffer) {
id = buffer.readVarInt();
}
@Override
public void toBytes(final PacketBuffer buffer) {
buffer.writeVarInt(id);
}
///////////////////////////////////////////////////////////////////
@Override
protected void handleMessage(final Supplier<NetworkEvent.Context> context) {
FileImportExportCardItemDevice.cancelImport(context.get().getSender(), id);
}
}