import com.irtimaled.bbor.common.VillageColorCache;
import com.irtimaled.bbor.config.ConfigManager;
import com.irtimaled.bbor.config.Setting;
-import net.minecraft.client.Minecraft;
-import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.world.dimension.DimensionType;
import java.net.InetSocketAddress;
@Override
public void init() {
super.init();
- EventBus.subscribe(Render.class, e -> render(e.getPartialTicks()));
+ EventBus.subscribe(Render.class, e -> render(e.getDimensionType()));
EventBus.subscribe(ConnectedToRemoteServer.class, e -> connectedToServer(e.getInternetAddress()));
EventBus.subscribe(DisconnectedFromRemoteServer.class, e -> disconnectedFromServer());
EventBus.subscribe(InitializeClientReceived.class, e -> setWorldData(e.getSeed(), e.getSpawnX(), e.getSpawnZ()));
KeyListener.init();
}
- private void render(float partialTicks) {
- EntityPlayer entityPlayer = Minecraft.getInstance().player;
- PlayerCoords.setPlayerPosition(partialTicks, entityPlayer);
-
+ private void render(DimensionType dimensionType) {
if (active) {
- renderer.render(DimensionType.getById(entityPlayer.dimension), ConfigManager.outerBoxesOnly.get());
+ renderer.render(dimensionType, ConfigManager.outerBoxesOnly.get());
}
}
private static double z;
private static double activeY;
- static void setPlayerPosition(double partialTicks, EntityPlayer entityPlayer) {
+ public static void setPlayerPosition(double partialTicks, EntityPlayer entityPlayer) {
x = entityPlayer.lastTickPosX + (entityPlayer.posX - entityPlayer.lastTickPosX) * partialTicks;
y = entityPlayer.lastTickPosY + (entityPlayer.posY - entityPlayer.lastTickPosY) * partialTicks;
z = entityPlayer.lastTickPosZ + (entityPlayer.posZ - entityPlayer.lastTickPosZ) * partialTicks;
package com.irtimaled.bbor.client.events;
+import net.minecraft.world.dimension.DimensionType;
+
public class Render {
- private final float partialTicks;
+ private DimensionType dimensionType;
- public Render(float partialTicks) {
- this.partialTicks = partialTicks;
+ public Render(DimensionType dimensionType) {
+ this.dimensionType = dimensionType;
}
- public float getPartialTicks() {
- return partialTicks;
+ public DimensionType getDimensionType() {
+ return dimensionType;
}
}
import com.irtimaled.bbor.common.messages.InitializeClient;
import com.irtimaled.bbor.common.messages.PayloadBuilder;
import com.irtimaled.bbor.common.messages.RemoveBoundingBox;
-import com.irtimaled.bbor.common.models.BoundingBox;
-import com.irtimaled.bbor.common.models.BoundingBoxMobSpawner;
-import com.irtimaled.bbor.common.models.Coords;
-import com.irtimaled.bbor.common.models.WorldData;
-import io.netty.channel.local.LocalAddress;
-import net.minecraft.entity.player.EntityPlayerMP;
+import com.irtimaled.bbor.common.models.*;
import net.minecraft.world.World;
import net.minecraft.world.WorldServer;
import net.minecraft.world.chunk.Chunk;
import java.util.function.Consumer;
public class CommonProxy {
- private Set<EntityPlayerMP> players = new HashSet<>();
- private Map<EntityPlayerMP, Set<BoundingBox>> playerBoundingBoxesCache = new HashMap<>();
+ private Set<ServerPlayer> players = new HashSet<>();
+ private Map<ServerPlayer, Set<BoundingBox>> playerBoundingBoxesCache = new HashMap<>();
private Map<DimensionType, VillageProcessor> villageProcessors = new HashMap<>();
private Map<DimensionType, ChunkProcessor> chunkProcessors = new HashMap<>();
private WorldData worldData = null;
}
}
- private void playerLoggedIn(EntityPlayerMP player) {
- if (player.connection.netManager.getRemoteAddress() instanceof LocalAddress) return;
- player.connection.sendPacket(InitializeClient.getPayload(worldData).build());
+ private void playerLoggedIn(ServerPlayer player) {
+ player.sendPacket(InitializeClient.getPayload(worldData));
}
- private void playerLoggedOut(EntityPlayerMP player) {
+ private void playerLoggedOut(ServerPlayer player) {
players.remove(player);
playerBoundingBoxesCache.remove(player);
}
private void sendRemoveBoundingBox(DimensionType dimensionType, BoundingBox boundingBox) {
- PayloadBuilder payloadBuilder = RemoveBoundingBox.getPayload(dimensionType, boundingBox);
- if (payloadBuilder == null) return;
+ PayloadBuilder payload = RemoveBoundingBox.getPayload(dimensionType, boundingBox);
+ if (payload == null) return;
- for (EntityPlayerMP player : players) {
- if (DimensionType.getById(player.dimension) == dimensionType) {
- player.connection.sendPacket(payloadBuilder.build());
+ for (ServerPlayer player : players) {
+ if (player.getDimensionType() == dimensionType) {
+ player.sendPacket(payload);
if (playerBoundingBoxesCache.containsKey(player)) {
playerBoundingBoxesCache.get(player).remove(boundingBox);
}
}
- private void sendBoundingBoxes(EntityPlayerMP player) {
- DimensionType dimensionType = DimensionType.getById(player.dimension);
+ private void sendBoundingBoxes(ServerPlayer player) {
+ DimensionType dimensionType = player.getDimensionType();
players.add(player);
sendToPlayer(player, getCache(dimensionType));
}
- private void sendToPlayer(EntityPlayerMP player, BoundingBoxCache boundingBoxCache) {
+ private void sendToPlayer(ServerPlayer player, BoundingBoxCache boundingBoxCache) {
if (boundingBoxCache == null) return;
Map<BoundingBox, Set<BoundingBox>> cacheSubset = getBoundingBoxMap(player, boundingBoxCache.getBoundingBoxes());
- DimensionType dimensionType = DimensionType.getById(player.dimension);
+ DimensionType dimensionType = player.getDimensionType();
for (BoundingBox key : cacheSubset.keySet()) {
Set<BoundingBox> boundingBoxes = cacheSubset.get(key);
- PayloadBuilder payloadBuilder = AddBoundingBox.getPayload(dimensionType, key, boundingBoxes);
- if (payloadBuilder != null)
- player.connection.sendPacket(payloadBuilder.build());
+ PayloadBuilder payload = AddBoundingBox.getPayload(dimensionType, key, boundingBoxes);
+ if (payload != null)
+ player.sendPacket(payload);
if (!playerBoundingBoxesCache.containsKey(player)) {
playerBoundingBoxesCache.put(player, new HashSet<>());
}
}
- private Map<BoundingBox, Set<BoundingBox>> getBoundingBoxMap(EntityPlayerMP player, Map<BoundingBox, Set<BoundingBox>> boundingBoxMap) {
+ private Map<BoundingBox, Set<BoundingBox>> getBoundingBoxMap(ServerPlayer player, Map<BoundingBox, Set<BoundingBox>> boundingBoxMap) {
Map<BoundingBox, Set<BoundingBox>> cacheSubset = new HashMap<>();
for (BoundingBox key : boundingBoxMap.keySet()) {
if (!playerBoundingBoxesCache.containsKey(player) || !playerBoundingBoxesCache.get(player).contains(key)) {
}
private void serverTick() {
- for (EntityPlayerMP player : players) {
- DimensionType dimensionType = DimensionType.getById(player.dimension);
+ for (ServerPlayer player : players) {
+ DimensionType dimensionType = player.getDimensionType();
sendToPlayer(player, getCache(dimensionType));
}
}
package com.irtimaled.bbor.common.events;
-import net.minecraft.entity.player.EntityPlayerMP;
+import com.irtimaled.bbor.common.models.ServerPlayer;
public class PlayerLoggedIn {
- private final EntityPlayerMP player;
+ private final ServerPlayer player;
- public PlayerLoggedIn(EntityPlayerMP player) {
+ public PlayerLoggedIn(ServerPlayer player) {
this.player = player;
}
- public EntityPlayerMP getPlayer() {
+ public ServerPlayer getPlayer() {
return player;
}
}
package com.irtimaled.bbor.common.events;
-import net.minecraft.entity.player.EntityPlayerMP;
+import com.irtimaled.bbor.common.models.ServerPlayer;
public class PlayerLoggedOut {
- private final EntityPlayerMP player;
+ private final ServerPlayer player;
- public PlayerLoggedOut(EntityPlayerMP player) {
+ public PlayerLoggedOut(ServerPlayer player) {
this.player = player;
}
- public EntityPlayerMP getPlayer() {
+ public ServerPlayer getPlayer() {
return player;
}
}
package com.irtimaled.bbor.common.events;
-import net.minecraft.entity.player.EntityPlayerMP;
+import com.irtimaled.bbor.common.models.ServerPlayer;
public class PlayerSubscribed {
- private final EntityPlayerMP player;
+ private final ServerPlayer player;
- public PlayerSubscribed(EntityPlayerMP player) {
+ public PlayerSubscribed(ServerPlayer player) {
this.player = player;
}
- public EntityPlayerMP getPlayer() {
+ public ServerPlayer getPlayer() {
return player;
}
}
--- /dev/null
+package com.irtimaled.bbor.common.models;
+
+import com.irtimaled.bbor.common.messages.PayloadBuilder;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.network.Packet;
+import net.minecraft.world.dimension.DimensionType;
+
+import java.util.function.Consumer;
+
+public class ServerPlayer {
+ private final DimensionType dimensionType;
+ private final Consumer<Packet<?>> packetConsumer;
+ private final int playerId;
+
+ public ServerPlayer(EntityPlayerMP player) {
+ this.dimensionType = DimensionType.getById(player.dimension);
+ this.packetConsumer = player.connection::sendPacket;
+ this.playerId = player.getEntityId();
+ }
+
+ public DimensionType getDimensionType() {
+ return dimensionType;
+ }
+
+ public void sendPacket(PayloadBuilder payloadBuilder) {
+ packetConsumer.accept(payloadBuilder.build());
+ }
+
+ @Override
+ public int hashCode() {
+ return playerId;
+ }
+}
package com.irtimaled.bbor.mixin.client.renderer;
+import com.irtimaled.bbor.client.PlayerCoords;
import com.irtimaled.bbor.client.events.Render;
import com.irtimaled.bbor.common.EventBus;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.client.renderer.EntityRenderer;
+import net.minecraft.world.dimension.DimensionType;
+import org.spongepowered.asm.mixin.Final;
import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(EntityRenderer.class)
public class MixinEntityRenderer {
+ @Shadow
+ @Final
+ private Minecraft mc;
+
@Inject(method = "updateCameraAndRender(FJ)V", at = @At(value = "INVOKE_STRING", target = "Lnet/minecraft/profiler/Profiler;endStartSection(Ljava/lang/String;)V", args = "ldc=hand", shift = At.Shift.BEFORE))
private void render(float partialTicks, long ignored, CallbackInfo ci) {
- EventBus.publish(new Render(partialTicks));
+ EntityPlayerSP player = this.mc.player;
+ PlayerCoords.setPlayerPosition(partialTicks, player);
+ EventBus.publish(new Render(DimensionType.getById(player.dimension)));
}
}
import com.irtimaled.bbor.common.EventBus;
import com.irtimaled.bbor.common.events.PlayerSubscribed;
import com.irtimaled.bbor.common.messages.SubscribeToServer;
-import net.minecraft.entity.player.EntityPlayerMP;
+import com.irtimaled.bbor.common.models.ServerPlayer;
import net.minecraft.network.NetHandlerPlayServer;
import net.minecraft.network.play.INetHandlerPlayServer;
import net.minecraft.network.play.client.CPacketCustomPayload;
@Redirect(method = "processPacket", at = @At(value = "INVOKE", target = "Lnet/minecraft/network/play/INetHandlerPlayServer;processCustomPayload(Lnet/minecraft/network/play/client/CPacketCustomPayload;)V"))
private void processPacket(INetHandlerPlayServer netHandlerPlayServer, CPacketCustomPayload packet) {
if (this.channel.toString().equals(SubscribeToServer.NAME)) {
- EntityPlayerMP player = ((NetHandlerPlayServer) netHandlerPlayServer).player;
+ ServerPlayer player = new ServerPlayer(((NetHandlerPlayServer) netHandlerPlayServer).player);
EventBus.publish(new PlayerSubscribed(player));
} else {
netHandlerPlayServer.processCustomPayload(packet);
import com.irtimaled.bbor.common.EventBus;
import com.irtimaled.bbor.common.events.PlayerLoggedIn;
import com.irtimaled.bbor.common.events.PlayerLoggedOut;
+import com.irtimaled.bbor.common.models.ServerPlayer;
+import io.netty.channel.local.LocalAddress;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.server.management.PlayerList;
import org.spongepowered.asm.mixin.Mixin;
public class MixinPlayerList {
@Inject(method = "playerLoggedIn", at = @At("RETURN"))
private void playerLoggedIn(EntityPlayerMP player, CallbackInfo ci) {
- EventBus.publish(new PlayerLoggedIn(player));
+ if(player.connection.netManager.getRemoteAddress() instanceof LocalAddress) return;
+ EventBus.publish(new PlayerLoggedIn(new ServerPlayer(player)));
}
@Inject(method = "playerLoggedOut", at = @At("HEAD"))
private void playerLoggedOut(EntityPlayerMP player, CallbackInfo ci) {
- EventBus.publish(new PlayerLoggedOut(player));
+ EventBus.publish(new PlayerLoggedOut(new ServerPlayer(player)));
}
}