Skip to content

Commit 7a2604c

Browse files
robotgryphonrobotgryphon
committed
Packet rewrites for multiple entrypoints
1 parent 3482836 commit 7a2604c

File tree

7 files changed

+149
-80
lines changed

7 files changed

+149
-80
lines changed

‎src/main/java/com/robotgryphon/compactmachines/block/tiles/TunnelWallTile.java‎

Lines changed: 1 addition & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -41,21 +41,6 @@ public TunnelWallTile() {
4141
super(Registration.TUNNEL_WALL_TILE.get());
4242
}
4343

44-
public Optional<CompactMachineInternalData> getMachineInfo() {
45-
if (this.level instanceof ServerWorld) {
46-
ServerWorld serverWorld = (ServerWorld) this.level;
47-
ChunkPos p = new ChunkPos(worldPosition);
48-
49-
InternalMachineData intern = InternalMachineData.get(serverWorld.getServer());
50-
if (intern == null)
51-
return Optional.empty();
52-
53-
return intern.forChunk(p);
54-
}
55-
56-
return Optional.empty();
57-
}
58-
5944
@Override
6045
public void load(BlockState state, CompoundNBT nbt) {
6146
super.load(state, nbt);
@@ -199,8 +184,6 @@ public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap) {
199184
@Nonnull
200185
@Override
201186
public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {
202-
Direction tunnelInDir = getConnectedSide();
203-
204187
Optional<TunnelDefinition> tunnelDef = getTunnelDefinition();
205188

206189
// If we don't have a definition for the tunnel, skip
@@ -210,7 +193,7 @@ public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable D
210193
// loop through tunnel definition for capabilities
211194
TunnelDefinition definition = tunnelDef.get();
212195
if (definition instanceof ICapableTunnel) {
213-
if (!level.isClientSide()) {
196+
if (!level.isClientSide) {
214197
ServerWorld sw = (ServerWorld) level;
215198
return ((ICapableTunnel) definition).getExternalCapability(sw, worldPosition, cap, side);
216199
}

‎src/main/java/com/robotgryphon/compactmachines/client/machine/MachinePlayerEventHandler.java‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -14,10 +14,15 @@ public static void handlePlayerMachineChanged(UUID playerID,
1414
MachinePlayersChangedPacket.EnumPlayerChangeType changeType,
1515
DimensionalPosition pos) {
1616
ClientWorld w = Minecraft.getInstance().level;
17+
if(w == null)
18+
return;
1719

1820
if (w.dimension() != pos.getDimension())
1921
return;
2022

23+
if(!w.isLoaded(pos.getBlockPosition()))
24+
return;
25+
2126
CompactMachineTile tile = (CompactMachineTile) w.getBlockEntity(pos.getBlockPosition());
2227
if (tile == null)
2328
return;

‎src/main/java/com/robotgryphon/compactmachines/data/world/ExternalMachineData.java‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -179,4 +179,14 @@ public void setMachineLocation(int machineId, DimensionalPosition position) {
179179
public DimensionalPosition getMachineLocation(int machineId) {
180180
return machineLocations.get(machineId);
181181
}
182+
183+
public Set<DimensionalPosition> getExternalMachineLocations(ChunkPos inside) {
184+
Set<Integer> externIDs = getExternalMachineIDs(inside);
185+
186+
return machineLocations.entrySet()
187+
.stream()
188+
.filter(in -> externIDs.contains(in.getKey()))
189+
.map(Map.Entry::getValue)
190+
.collect(Collectors.toSet());
191+
}
182192
}

‎src/main/java/com/robotgryphon/compactmachines/network/MachinePlayersChangedPacket.java‎

Lines changed: 104 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -1,80 +1,145 @@
11
package com.robotgryphon.compactmachines.network;
22

33
import com.google.common.collect.ImmutableSet;
4+
import com.mojang.serialization.Codec;
5+
import com.mojang.serialization.codecs.RecordCodecBuilder;
46
import com.robotgryphon.compactmachines.CompactMachines;
57
import com.robotgryphon.compactmachines.client.machine.MachinePlayerEventHandler;
6-
import com.robotgryphon.compactmachines.data.legacy.CompactMachineServerData;
7-
import com.robotgryphon.compactmachines.data.legacy.SavedMachineData;
8-
import com.robotgryphon.compactmachines.data.legacy.CompactMachineRegistrationData;
8+
import com.robotgryphon.compactmachines.data.codec.CodecExtensions;
9+
import com.robotgryphon.compactmachines.data.world.ExternalMachineData;
910
import com.robotgryphon.compactmachines.teleportation.DimensionalPosition;
11+
import net.minecraft.entity.player.ServerPlayerEntity;
1012
import net.minecraft.network.PacketBuffer;
1113
import net.minecraft.server.MinecraftServer;
14+
import net.minecraft.util.math.ChunkPos;
1215
import net.minecraftforge.fml.network.NetworkEvent;
1316

1417
import javax.annotation.Nullable;
15-
import java.util.Optional;
16-
import java.util.UUID;
18+
import java.io.IOException;
19+
import java.util.*;
1720
import java.util.function.Supplier;
1821

1922
public class MachinePlayersChangedPacket {
2023

21-
private MinecraftServer server;
22-
public int machineID;
24+
public ChunkPos machine;
25+
public UUID playerID;
2326
public ImmutableSet<DimensionalPosition> machinePositions;
2427
public EnumPlayerChangeType type;
25-
public UUID playerID;
2628

27-
public MachinePlayersChangedPacket(@Nullable MinecraftServer server, int machineID, UUID id, EnumPlayerChangeType type) {
28-
this.server = server;
29-
this.machineID = machineID;
30-
this.machinePositions = ImmutableSet.of();
31-
this.playerID = id;
32-
this.type = type;
29+
public static final Codec<MachinePlayersChangedPacket> CODEC = RecordCodecBuilder.create(i -> i.group(
30+
CodecExtensions.CHUNKPOS_CODEC.fieldOf("machine").forGetter(MachinePlayersChangedPacket::getChunkPos),
31+
CodecExtensions.UUID_CODEC.fieldOf("player").forGetter(MachinePlayersChangedPacket::getPlayer),
32+
Codec.STRING.fieldOf("type").forGetter((p) -> p.type.name()),
33+
DimensionalPosition.CODEC.listOf().fieldOf("positions").forGetter(p -> p.machinePositions.asList())
34+
).apply(i, MachinePlayersChangedPacket::new));
35+
36+
public MachinePlayersChangedPacket(PacketBuffer buf) {
37+
try {
38+
MachinePlayersChangedPacket pkt = buf.readWithCodec(MachinePlayersChangedPacket.CODEC);
39+
40+
machine = pkt.machine;
41+
playerID = pkt.playerID;
42+
machinePositions = pkt.machinePositions;
43+
type = pkt.type;
44+
} catch (IOException e) {
45+
CompactMachines.LOGGER.error(e);
46+
}
47+
}
48+
49+
private MachinePlayersChangedPacket(ChunkPos chunkPos, UUID player, String type, Collection<DimensionalPosition> positions) {
50+
this.machine = chunkPos;
51+
this.playerID = player;
52+
this.type = EnumPlayerChangeType.valueOf(type);
53+
this.machinePositions = ImmutableSet.copyOf(positions);
3354
}
3455

3556
public static void handle(MachinePlayersChangedPacket message, Supplier<NetworkEvent.Context> context) {
3657
NetworkEvent.Context ctx = context.get();
3758

3859
message.machinePositions.forEach(machinePos -> {
39-
CompactMachines.LOGGER.debug("Player changed machine {}; outer position {}", message.machineID, machinePos);
60+
CompactMachines.LOGGER.debug("Player changed inside {}; outer position {}", message.machine, machinePos);
4061
MachinePlayerEventHandler.handlePlayerMachineChanged(message.playerID, message.type, machinePos);
4162
});
4263

4364
ctx.setPacketHandled(true);
4465
}
4566

4667
public static void encode(MachinePlayersChangedPacket pkt, PacketBuffer buf) {
47-
buf.writeInt(pkt.machineID);
48-
buf.writeUUID(pkt.playerID);
49-
buf.writeUtf(pkt.type.toString());
50-
51-
SavedMachineData md = SavedMachineData.getInstance(pkt.server);
52-
CompactMachineServerData data = md.getData();
53-
54-
Optional<CompactMachineRegistrationData> machineData = data.getMachineData(pkt.machineID);
55-
buf.writeBoolean(machineData.isPresent());
56-
machineData.ifPresent(mData -> {
57-
DimensionalPosition out = mData.getOutsidePosition(pkt.server);
58-
buf.writeNbt(out.serializeNBT());
59-
});
68+
try {
69+
buf.writeWithCodec(CODEC, pkt);
70+
} catch (IOException e) {
71+
CompactMachines.LOGGER.error(e);
72+
}
6073
}
6174

62-
public static MachinePlayersChangedPacket decode(PacketBuffer buf) {
63-
int machine = buf.readInt();
64-
UUID id = buf.readUUID();
65-
EnumPlayerChangeType changeType = EnumPlayerChangeType.valueOf(buf.readUtf());
66-
67-
MachinePlayersChangedPacket pkt = new MachinePlayersChangedPacket(null, machine, id, changeType);
68-
if(buf.readBoolean()) {
69-
DimensionalPosition tilePos = DimensionalPosition.fromNBT(buf.readNbt());
70-
pkt.machinePositions = ImmutableSet.of(tilePos);
71-
}
75+
private UUID getPlayer() {
76+
return playerID;
77+
}
7278

73-
return pkt;
79+
private ChunkPos getChunkPos() {
80+
return machine;
7481
}
7582

7683
public enum EnumPlayerChangeType {
7784
ENTERED,
7885
EXITED
7986
}
87+
88+
public static class Builder {
89+
90+
private final MinecraftServer server;
91+
private EnumPlayerChangeType change;
92+
private ChunkPos chunk;
93+
private UUID player;
94+
private int entryPoint;
95+
96+
private Builder(MinecraftServer server) {
97+
this.server = server;
98+
this.change = EnumPlayerChangeType.EXITED;
99+
}
100+
101+
public static Builder create(MinecraftServer server) {
102+
return new Builder(server);
103+
}
104+
105+
@Nullable
106+
public MachinePlayersChangedPacket build() {
107+
ExternalMachineData extern = ExternalMachineData.get(server);
108+
if(extern == null)
109+
{
110+
CompactMachines.LOGGER.fatal("Could not load external machine data from server.");
111+
return null;
112+
}
113+
114+
Set<DimensionalPosition> externalMachineIDs = extern.getExternalMachineLocations(chunk);
115+
116+
return new MachinePlayersChangedPacket(chunk, player, change.name(), externalMachineIDs);
117+
}
118+
119+
public Builder forMachine(ChunkPos insideChunk) {
120+
this.chunk = insideChunk;
121+
return this;
122+
}
123+
124+
public Builder forPlayer(ServerPlayerEntity player) {
125+
this.player = player.getUUID();
126+
return this;
127+
}
128+
129+
public Builder forPlayer(UUID player) {
130+
this.player = player;
131+
return this;
132+
}
133+
134+
public Builder enteredFrom(int machineId) {
135+
this.entryPoint = machineId;
136+
this.change = EnumPlayerChangeType.ENTERED;
137+
return this;
138+
}
139+
140+
public Builder exited() {
141+
this.change = EnumPlayerChangeType.EXITED;
142+
return this;
143+
}
144+
}
80145
}

‎src/main/java/com/robotgryphon/compactmachines/network/NetworkHandler.java‎

Lines changed: 10 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -19,12 +19,16 @@ public class NetworkHandler {
1919
);
2020

2121
public static void initialize() {
22-
MAIN_CHANNEL.registerMessage(index++, MachinePlayersChangedPacket.class,
23-
MachinePlayersChangedPacket::encode, MachinePlayersChangedPacket::decode,
24-
MachinePlayersChangedPacket::handle, Optional.of(NetworkDirection.PLAY_TO_CLIENT));
22+
MAIN_CHANNEL.messageBuilder(MachinePlayersChangedPacket.class, index++, NetworkDirection.PLAY_TO_CLIENT)
23+
.encoder(MachinePlayersChangedPacket::encode)
24+
.decoder(MachinePlayersChangedPacket::new)
25+
.consumer(MachinePlayersChangedPacket::handle)
26+
.add();
2527

26-
MAIN_CHANNEL.registerMessage(index++, TunnelAddedPacket.class,
27-
TunnelAddedPacket::encode, TunnelAddedPacket::decode,
28-
TunnelAddedPacket::handle, Optional.of(NetworkDirection.PLAY_TO_CLIENT));
28+
MAIN_CHANNEL.messageBuilder(TunnelAddedPacket.class, index++, NetworkDirection.PLAY_TO_CLIENT)
29+
.encoder(TunnelAddedPacket::encode)
30+
.decoder(TunnelAddedPacket::new)
31+
.consumer(TunnelAddedPacket::handle)
32+
.add();
2933
}
3034
}

‎src/main/java/com/robotgryphon/compactmachines/network/TunnelAddedPacket.java‎

Lines changed: 7 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -12,17 +12,19 @@
1212

1313
public class TunnelAddedPacket {
1414

15-
private BlockPos position;
16-
private ResourceLocation type;
17-
18-
private TunnelAddedPacket() {
19-
}
15+
private final BlockPos position;
16+
private final ResourceLocation type;
2017

2118
public TunnelAddedPacket(BlockPos tunnelPos, ResourceLocation tunnelType) {
2219
this.position = tunnelPos;
2320
this.type = tunnelType;
2421
}
2522

23+
public TunnelAddedPacket(PacketBuffer buf) {
24+
position = buf.readBlockPos();
25+
type = buf.readResourceLocation();
26+
}
27+
2628
public static void handle(TunnelAddedPacket message, Supplier<NetworkEvent.Context> context) {
2729
NetworkEvent.Context ctx = context.get();
2830

@@ -40,12 +42,4 @@ public static void encode(TunnelAddedPacket pkt, PacketBuffer buf) {
4042
buf.writeBlockPos(pkt.position);
4143
buf.writeResourceLocation(pkt.type);
4244
}
43-
44-
public static TunnelAddedPacket decode(PacketBuffer buf) {
45-
TunnelAddedPacket pkt = new TunnelAddedPacket();
46-
pkt.position = buf.readBlockPos();
47-
pkt.type = buf.readResourceLocation();
48-
49-
return pkt;
50-
}
5145
}

‎src/main/java/com/robotgryphon/compactmachines/util/PlayerUtil.java‎

Lines changed: 12 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -27,7 +27,6 @@
2727
import net.minecraft.util.text.TranslationTextComponent;
2828
import net.minecraft.world.IWorld;
2929
import net.minecraft.world.World;
30-
import net.minecraft.world.chunk.Chunk;
3130
import net.minecraft.world.server.ServerWorld;
3231
import net.minecraftforge.fml.network.PacketDistributor;
3332

@@ -105,7 +104,7 @@ public static void teleportPlayerIntoMachine(ServerPlayerEntity serverPlayer, Bl
105104
newCenter,
106105
newSpawn,
107106
size
108-
));
107+
));
109108
} catch (OperationNotSupportedException e) {
110109
CompactMachines.LOGGER.warn(e);
111110
}
@@ -235,7 +234,12 @@ public static void addPlayerToMachine(ServerPlayerEntity serverPlayer, BlockPos
235234
playerData.addPlayer(serverPlayer, mChunk);
236235
playerData.setDirty();
237236

238-
MachinePlayersChangedPacket p = new MachinePlayersChangedPacket(serv, tile.machineId, serverPlayer.getUUID(), MachinePlayersChangedPacket.EnumPlayerChangeType.ENTERED);
237+
MachinePlayersChangedPacket p = MachinePlayersChangedPacket.Builder.create(serv)
238+
.forMachine(mChunk)
239+
.forPlayer(serverPlayer)
240+
.enteredFrom(tile.machineId)
241+
.build();
242+
239243
NetworkHandler.MAIN_CHANNEL.send(
240244
PacketDistributor.TRACKING_CHUNK.with(() -> serverPlayer.getLevel().getChunkAt(machinePos)),
241245
p);
@@ -260,7 +264,11 @@ public static void removePlayerFromMachine(ServerPlayerEntity serverPlayer, Bloc
260264
playerData.removePlayer(serverPlayer);
261265
playerData.setDirty();
262266

263-
MachinePlayersChangedPacket p = new MachinePlayersChangedPacket(serv, tile.machineId, serverPlayer.getUUID(), MachinePlayersChangedPacket.EnumPlayerChangeType.EXITED);
267+
MachinePlayersChangedPacket p = MachinePlayersChangedPacket.Builder.create(serv)
268+
.forMachine(mChunk)
269+
.forPlayer(serverPlayer)
270+
.build();
271+
264272
NetworkHandler.MAIN_CHANNEL.send(
265273
PacketDistributor.TRACKING_CHUNK.with(() -> serverPlayer.getLevel().getChunkAt(machinePos)),
266274
p);

0 commit comments

Comments
 (0)