2023-03-15 21:52:13 +00:00
|
|
|
// SPDX-FileCopyrightText: 2018 The CC: Tweaked Developers
|
|
|
|
//
|
|
|
|
// SPDX-License-Identifier: MPL-2.0
|
|
|
|
|
2018-12-29 12:18:05 +00:00
|
|
|
package dan200.computercraft.shared.network.client;
|
|
|
|
|
2024-04-25 20:32:48 +00:00
|
|
|
import dan200.computercraft.shared.computer.menu.ComputerMenu;
|
2022-10-30 09:20:26 +00:00
|
|
|
import dan200.computercraft.shared.computer.terminal.TerminalState;
|
Remove ClientComputer
Historically CC has maintained two computer registries; one on the
server (which runs the actual computer) and one on the client (which
stores the terminal and some small bits of additional data).
This means when a user opens the computer UI, we send the terminal
contents and store it in the client computer registry. We then send the
instance id alongside the "open container" packet, which is used to look
up the client computer (and thus terminal) in our client-side registry.
This patch makes the computer menu syncing behaviour more consistent
with vanilla. The initial terminal contents is sent alongside the "open
container" packet, and subsequent terminal changes apply /just/ to the
open container. Computer on/off state is synced via a vanilla
ContainerData/IIntArray.
Likewise, sending user input to the server now targets the open
container, rather than an arbitrary instance id.
The one remaining usage of ClientComputer is for pocket computers. For
these, we still need to sync the current on/off/blinking state and the
pocket computer light.
We don't need the full ClientComputer interface for this case (after
all, you can't send input to a pocket computer someone else is
holding!). This means we can tear out ClientComputer and
ClientComputerRegistry, replacing it with a much simpler
ClientPocketComputers store.
This in turn allows the following changes:
- Remove IComputer, as we no longer need to abstract over client and
server computers.
- Likewise, we can merge ComputerRegistry into the server
registry. This commit also cleans up the handling of instance IDs a
little bit: ServerComputers are now responsible for generating their
ID and adding/removing themselves from the registry.
- As the client-side terminal will never be null, we can remove a whole
bunch of null checks throughout the codebase.
- As the terminal is available immediately, we don't need to explicitly
pass in terminal sizes to the computer GUIs. This means we're no
longer reliant on those config values on the client side!
- Remove the "request computer state" packet. Pocket computers now
store which players need to know the computer state, automatically
sending data when a new player starts tracking the computer.
2022-10-21 17:17:42 +00:00
|
|
|
import dan200.computercraft.shared.network.NetworkMessage;
|
Add a MessageType for network messages
Everything old is new again!
CC's network message implementation has gone through several iterations:
- Originally network messages were implemented with a single class,
which held an packet id/type and and opaque blobs of data (as
string/int/byte/NBT arrays), and a big switch statement to decode and
process this data.
- In 42d3901ee37892e259de26ebb57cf59ce284416e, we split the messages
into different classes all inheriting from NetworkMessage - this bit
we've stuck with ever since.
Each packet had a `getId(): int` method, which returned the
discriminator for this packet.
- However, getId() was only used when registering the packet, not when
sending, and so in ce0685c31f7315d15d3250c6c8605171b33aa99f we
removed it, just passing in a constant integer at registration
instead.
- In 53abe5e56eec6840890770b6ec36a5d009357da7, we made some relatively
minor changes to make the code more multi-loader/split-source
friendly. However, this meant when we finally came to add Fabric
support (8152f19b6efd71b66c3821ad94aacaddb7d26298), we had to
re-implement a lot of Forge's network code.
In 1.20.4, Forge moves to a system much closer to Fabric's (and indeed,
Minecraft's own CustomPacketPayload), and so it makes sense to adapt to
that now. As such, we:
- Add a new MessageType interface. This is implemented by the
loader-specific modules, and holds whatever information is needed to
register the packet (e.g. discriminator, reader function).
- Each NetworkMessage now has a type(): MessageType<?> function. This
is used by the Fabric networking code (and for NeoForge's on 1.20.4)
instead of a class lookup.
- NetworkMessages now creates/stores these MessageType<T>s (much like
we'd do for registries), and provides getters for the
clientbound/serverbound messages. Mod initialisers then call these
getters to register packets.
- For Forge, this is relatively unchanged. For Fabric, we now
`FabricPacket`s.
2024-01-03 09:15:38 +00:00
|
|
|
import dan200.computercraft.shared.network.NetworkMessages;
|
2024-04-25 20:32:48 +00:00
|
|
|
import net.minecraft.network.RegistryFriendlyByteBuf;
|
|
|
|
import net.minecraft.network.codec.ByteBufCodecs;
|
|
|
|
import net.minecraft.network.codec.StreamCodec;
|
|
|
|
import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
|
2022-10-25 21:36:21 +00:00
|
|
|
import net.minecraft.world.inventory.AbstractContainerMenu;
|
2018-12-29 12:18:05 +00:00
|
|
|
|
2024-04-25 20:32:48 +00:00
|
|
|
/**
|
|
|
|
* Update the terminal for the currently opened {@link ComputerMenu}.
|
|
|
|
*
|
|
|
|
* @param containerId The currently opened container id.
|
|
|
|
* @param terminal The new terminal data.
|
|
|
|
*/
|
|
|
|
public record ComputerTerminalClientMessage(
|
|
|
|
int containerId, TerminalState terminal
|
|
|
|
) implements NetworkMessage<ClientNetworkContext> {
|
|
|
|
public static final StreamCodec<RegistryFriendlyByteBuf, ComputerTerminalClientMessage> STREAM_CODEC = StreamCodec.composite(
|
|
|
|
ByteBufCodecs.VAR_INT, ComputerTerminalClientMessage::containerId,
|
|
|
|
TerminalState.STREAM_CODEC, ComputerTerminalClientMessage::terminal,
|
|
|
|
ComputerTerminalClientMessage::new
|
|
|
|
);
|
2018-12-29 12:18:05 +00:00
|
|
|
|
2022-10-25 21:36:21 +00:00
|
|
|
public ComputerTerminalClientMessage(AbstractContainerMenu menu, TerminalState terminal) {
|
2024-04-25 20:32:48 +00:00
|
|
|
this(menu.containerId, terminal);
|
2018-12-29 12:18:05 +00:00
|
|
|
}
|
|
|
|
|
2019-01-12 19:42:34 +00:00
|
|
|
@Override
|
2022-11-06 20:12:32 +00:00
|
|
|
public void handle(ClientNetworkContext context) {
|
|
|
|
context.handleComputerTerminal(containerId, terminal);
|
2019-01-12 19:42:34 +00:00
|
|
|
}
|
Add a MessageType for network messages
Everything old is new again!
CC's network message implementation has gone through several iterations:
- Originally network messages were implemented with a single class,
which held an packet id/type and and opaque blobs of data (as
string/int/byte/NBT arrays), and a big switch statement to decode and
process this data.
- In 42d3901ee37892e259de26ebb57cf59ce284416e, we split the messages
into different classes all inheriting from NetworkMessage - this bit
we've stuck with ever since.
Each packet had a `getId(): int` method, which returned the
discriminator for this packet.
- However, getId() was only used when registering the packet, not when
sending, and so in ce0685c31f7315d15d3250c6c8605171b33aa99f we
removed it, just passing in a constant integer at registration
instead.
- In 53abe5e56eec6840890770b6ec36a5d009357da7, we made some relatively
minor changes to make the code more multi-loader/split-source
friendly. However, this meant when we finally came to add Fabric
support (8152f19b6efd71b66c3821ad94aacaddb7d26298), we had to
re-implement a lot of Forge's network code.
In 1.20.4, Forge moves to a system much closer to Fabric's (and indeed,
Minecraft's own CustomPacketPayload), and so it makes sense to adapt to
that now. As such, we:
- Add a new MessageType interface. This is implemented by the
loader-specific modules, and holds whatever information is needed to
register the packet (e.g. discriminator, reader function).
- Each NetworkMessage now has a type(): MessageType<?> function. This
is used by the Fabric networking code (and for NeoForge's on 1.20.4)
instead of a class lookup.
- NetworkMessages now creates/stores these MessageType<T>s (much like
we'd do for registries), and provides getters for the
clientbound/serverbound messages. Mod initialisers then call these
getters to register packets.
- For Forge, this is relatively unchanged. For Fabric, we now
`FabricPacket`s.
2024-01-03 09:15:38 +00:00
|
|
|
|
|
|
|
@Override
|
2024-04-25 20:32:48 +00:00
|
|
|
public CustomPacketPayload.Type<ComputerTerminalClientMessage> type() {
|
Add a MessageType for network messages
Everything old is new again!
CC's network message implementation has gone through several iterations:
- Originally network messages were implemented with a single class,
which held an packet id/type and and opaque blobs of data (as
string/int/byte/NBT arrays), and a big switch statement to decode and
process this data.
- In 42d3901ee37892e259de26ebb57cf59ce284416e, we split the messages
into different classes all inheriting from NetworkMessage - this bit
we've stuck with ever since.
Each packet had a `getId(): int` method, which returned the
discriminator for this packet.
- However, getId() was only used when registering the packet, not when
sending, and so in ce0685c31f7315d15d3250c6c8605171b33aa99f we
removed it, just passing in a constant integer at registration
instead.
- In 53abe5e56eec6840890770b6ec36a5d009357da7, we made some relatively
minor changes to make the code more multi-loader/split-source
friendly. However, this meant when we finally came to add Fabric
support (8152f19b6efd71b66c3821ad94aacaddb7d26298), we had to
re-implement a lot of Forge's network code.
In 1.20.4, Forge moves to a system much closer to Fabric's (and indeed,
Minecraft's own CustomPacketPayload), and so it makes sense to adapt to
that now. As such, we:
- Add a new MessageType interface. This is implemented by the
loader-specific modules, and holds whatever information is needed to
register the packet (e.g. discriminator, reader function).
- Each NetworkMessage now has a type(): MessageType<?> function. This
is used by the Fabric networking code (and for NeoForge's on 1.20.4)
instead of a class lookup.
- NetworkMessages now creates/stores these MessageType<T>s (much like
we'd do for registries), and provides getters for the
clientbound/serverbound messages. Mod initialisers then call these
getters to register packets.
- For Forge, this is relatively unchanged. For Fabric, we now
`FabricPacket`s.
2024-01-03 09:15:38 +00:00
|
|
|
return NetworkMessages.COMPUTER_TERMINAL;
|
|
|
|
}
|
2018-12-29 12:18:05 +00:00
|
|
|
}
|