mirror of
https://github.com/GTNewHorizons/Opis.git
synced 2026-11-21 04:32:28 +00:00
354 lines
16 KiB
Java
354 lines
16 KiB
Java
package mcp.mobius.opis.network;
|
|
|
|
import static cpw.mods.fml.relauncher.Side.CLIENT;
|
|
import static cpw.mods.fml.relauncher.Side.SERVER;
|
|
import io.netty.buffer.ByteBuf;
|
|
import io.netty.channel.ChannelHandlerContext;
|
|
import io.netty.channel.ChannelHandler.Sharable;
|
|
import io.netty.channel.SimpleChannelInboundHandler;
|
|
|
|
import java.lang.reflect.Constructor;
|
|
import java.util.ArrayList;
|
|
import java.util.EnumMap;
|
|
|
|
import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics;
|
|
import org.apache.logging.log4j.Level;
|
|
import org.apache.logging.log4j.LogManager;
|
|
import com.google.common.collect.HashBasedTable;
|
|
import com.google.common.collect.Maps;
|
|
import com.google.common.collect.Table.Cell;
|
|
import com.google.common.io.ByteArrayDataInput;
|
|
import com.google.common.io.ByteArrayDataOutput;
|
|
import com.google.common.io.ByteStreams;
|
|
|
|
import mcp.mobius.mobiuscore.profiler.ProfilerSection;
|
|
import mcp.mobius.opis.data.holders.ISerializable;
|
|
import mcp.mobius.opis.data.holders.basetypes.AmountHolder;
|
|
import mcp.mobius.opis.data.holders.basetypes.SerialInt;
|
|
import mcp.mobius.opis.data.holders.basetypes.SerialLong;
|
|
import mcp.mobius.opis.data.holders.newtypes.DataBlockTick;
|
|
import mcp.mobius.opis.data.holders.newtypes.DataBlockTileEntity;
|
|
import mcp.mobius.opis.data.holders.newtypes.DataBlockTileEntityPerClass;
|
|
import mcp.mobius.opis.data.holders.newtypes.DataEntity;
|
|
import mcp.mobius.opis.data.holders.newtypes.DataEntityPerClass;
|
|
import mcp.mobius.opis.data.holders.newtypes.DataEvent;
|
|
import mcp.mobius.opis.data.holders.newtypes.DataNetworkTick;
|
|
import mcp.mobius.opis.data.holders.newtypes.DataTiming;
|
|
import mcp.mobius.opis.data.holders.stats.StatsChunk;
|
|
import mcp.mobius.opis.data.managers.ChunkManager;
|
|
import mcp.mobius.opis.data.managers.EntityManager;
|
|
import mcp.mobius.opis.data.managers.TileEntityManager;
|
|
import mcp.mobius.opis.data.profilers.ProfilerEvent;
|
|
import mcp.mobius.opis.events.PlayerTracker;
|
|
import mcp.mobius.opis.network.enums.Message;
|
|
import mcp.mobius.opis.network.packets.client.PacketReqChunks;
|
|
import mcp.mobius.opis.network.packets.client.PacketReqData;
|
|
import mcp.mobius.opis.network.packets.server.NetDataCommand;
|
|
import mcp.mobius.opis.network.packets.server.NetDataList;
|
|
import mcp.mobius.opis.network.packets.server.NetDataValue;
|
|
import mcp.mobius.opis.network.packets.server.PacketChunks;
|
|
import net.minecraft.client.Minecraft;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.entity.player.EntityPlayerMP;
|
|
import cpw.mods.fml.common.FMLCommonHandler;
|
|
import cpw.mods.fml.common.network.FMLEmbeddedChannel;
|
|
import cpw.mods.fml.common.network.FMLIndexedMessageToMessageCodec;
|
|
import cpw.mods.fml.common.network.FMLOutboundHandler;
|
|
import cpw.mods.fml.common.network.NetworkRegistry;
|
|
import cpw.mods.fml.relauncher.Side;
|
|
import cpw.mods.fml.relauncher.SideOnly;
|
|
import net.minecraft.network.NetHandlerPlayServer;
|
|
import net.minecraft.network.Packet;
|
|
import net.minecraft.network.play.server.S02PacketChat;
|
|
import net.minecraft.util.ChatComponentText;
|
|
|
|
@Sharable
|
|
//public class PacketManager extends FMLIndexedMessageToMessageCodec<PacketBase>
|
|
public class PacketManager
|
|
{
|
|
//private static final PacketManager INSTANCE = new PacketManager();
|
|
//private static final Logger LOGGER = LogManager.getLogger();
|
|
private static final EnumMap<Side, FMLEmbeddedChannel> channels = Maps.newEnumMap(Side.class);
|
|
|
|
public static void init()
|
|
{
|
|
if (!channels.isEmpty()) // avoid duplicate inits..
|
|
return;
|
|
|
|
Codec codec = new Codec();
|
|
|
|
codec.addDiscriminator(0, PacketReqChunks.class);
|
|
codec.addDiscriminator(1, PacketReqData.class);
|
|
codec.addDiscriminator(2, NetDataCommand.class);
|
|
codec.addDiscriminator(3, NetDataList.class);
|
|
codec.addDiscriminator(4, NetDataValue.class);
|
|
codec.addDiscriminator(5, PacketChunks.class);
|
|
|
|
channels.putAll(NetworkRegistry.INSTANCE.newChannel("Opis", codec));
|
|
|
|
// add handlers
|
|
if (FMLCommonHandler.instance().getSide().isClient())
|
|
{
|
|
// for the client
|
|
FMLEmbeddedChannel channel = channels.get(Side.CLIENT);
|
|
String codecName = channel.findChannelHandlerNameForType(Codec.class);
|
|
channel.pipeline().addAfter(codecName, "ClientHandler", new HandlerClient());
|
|
}
|
|
//else
|
|
{
|
|
// for the server
|
|
FMLEmbeddedChannel channel = channels.get(Side.SERVER);
|
|
String codecName = channel.findChannelHandlerNameForType(Codec.class);
|
|
channel.pipeline().addAfter(codecName, "ServerHandler", new HandlerServer());
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* @author abrarsyed
|
|
* This class converts FMLMessage to PacketBase for my system to handle.
|
|
*/
|
|
private static final class Codec extends FMLIndexedMessageToMessageCodec<PacketBase>
|
|
{
|
|
@Override
|
|
public void encodeInto(ChannelHandlerContext ctx, PacketBase packet, ByteBuf target) throws Exception
|
|
{
|
|
ByteArrayDataOutput output = ByteStreams.newDataOutput();
|
|
packet.encode(output);
|
|
target.writeBytes(output.toByteArray());
|
|
}
|
|
|
|
@Override
|
|
public void decodeInto(ChannelHandlerContext ctx, ByteBuf source, PacketBase packet)
|
|
{
|
|
ByteArrayDataInput input = ByteStreams.newDataInput(source.array());
|
|
input.skipBytes(1); // skip the packet identifier byte
|
|
packet.decode(input);
|
|
|
|
if (FMLCommonHandler.instance().getEffectiveSide().isClient())
|
|
{
|
|
actionClient(packet);
|
|
}
|
|
else
|
|
{
|
|
actionServer(ctx, packet);
|
|
}
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
private void actionClient(PacketBase packet)
|
|
{
|
|
Minecraft mc = Minecraft.getMinecraft();
|
|
packet.actionClient(mc.theWorld, mc.thePlayer);
|
|
}
|
|
|
|
private void actionServer(ChannelHandlerContext ctx, PacketBase packet)
|
|
{
|
|
EntityPlayerMP player = ((NetHandlerPlayServer) ctx.channel().attr(NetworkRegistry.NET_HANDLER).get()).playerEntity;
|
|
packet.actionServer(player.worldObj, player);
|
|
}
|
|
|
|
@Override
|
|
public FMLIndexedMessageToMessageCodec<PacketBase> addDiscriminator(int discriminator, Class<? extends PacketBase> type)
|
|
{
|
|
// double check it has an empty constructor. or fail early.
|
|
// This is to guard myself against my own stupidity.
|
|
|
|
if (!hasEmptyContructor(type))
|
|
{
|
|
LogManager.getLogger().log(Level.FATAL, type.getName() + "does not have an empty constructor!");
|
|
}
|
|
|
|
return super.addDiscriminator(discriminator, type);
|
|
}
|
|
|
|
@SuppressWarnings("rawtypes")
|
|
private static boolean hasEmptyContructor(Class type)
|
|
{
|
|
try
|
|
{
|
|
for (Constructor c : type.getConstructors())
|
|
{
|
|
if (c.getParameterTypes().length == 0)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
catch (SecurityException e)
|
|
{
|
|
// really?
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@Sharable
|
|
@SideOnly(Side.CLIENT)
|
|
private static final class HandlerClient extends SimpleChannelInboundHandler<PacketBase>
|
|
{
|
|
@Override
|
|
protected void channelRead0(ChannelHandlerContext ctx, PacketBase packet) throws Exception
|
|
{
|
|
Minecraft mc = Minecraft.getMinecraft();
|
|
packet.actionClient(mc.theWorld, mc.thePlayer);
|
|
}
|
|
}
|
|
|
|
@Sharable
|
|
private static final class HandlerServer extends SimpleChannelInboundHandler<PacketBase>
|
|
{
|
|
@Override
|
|
protected void channelRead0(ChannelHandlerContext ctx, PacketBase packet) throws Exception
|
|
{
|
|
EntityPlayerMP player = ((NetHandlerPlayServer) ctx.channel().attr(NetworkRegistry.NET_HANDLER).get()).playerEntity;
|
|
packet.actionServer(player.worldObj, player);
|
|
}
|
|
}
|
|
|
|
// UTIL SENDING METHODS
|
|
|
|
public static void sendToServer(PacketBase packet)
|
|
{
|
|
channels.get(CLIENT).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.TOSERVER);
|
|
channels.get(CLIENT).writeAndFlush(packet);
|
|
}
|
|
|
|
public static void sendToPlayer(PacketBase packet, EntityPlayer player)
|
|
{
|
|
channels.get(SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.PLAYER);
|
|
channels.get(SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(player);
|
|
channels.get(SERVER).writeAndFlush(packet);
|
|
}
|
|
|
|
public static void sendToPlayer(Packet packet, EntityPlayerMP player)
|
|
{
|
|
player.playerNetServerHandler.sendPacket(packet);
|
|
}
|
|
|
|
public static void sendToAllAround(PacketBase packet, NetworkRegistry.TargetPoint point)
|
|
{
|
|
channels.get(SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.ALLAROUNDPOINT);
|
|
channels.get(SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(point);
|
|
channels.get(SERVER).writeAndFlush(packet);
|
|
}
|
|
|
|
public static void sendToDimension(PacketBase packet, int dimension)
|
|
{
|
|
channels.get(SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.DIMENSION);
|
|
channels.get(SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(dimension);
|
|
channels.get(SERVER).writeAndFlush(packet);
|
|
}
|
|
|
|
public static void sendToAll(PacketBase packet)
|
|
{
|
|
channels.get(SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.ALL);
|
|
channels.get(SERVER).writeAndFlush(packet);
|
|
}
|
|
|
|
public static Packet toMcPacket(PacketBase packet)
|
|
{
|
|
return channels.get(FMLCommonHandler.instance().getEffectiveSide()).generatePacketFrom(packet);
|
|
}
|
|
|
|
/*
|
|
public void writeString(ByteArrayDataOutput buffer, String data) throws IOException
|
|
{
|
|
byte[] abyte = data.getBytes(Charsets.UTF_8);
|
|
buffer.writeShort(abyte.length);
|
|
buffer.writeBytes(abyte);
|
|
}
|
|
|
|
public String readString(ByteArrayDataInput buffer) throws IOException
|
|
{
|
|
int j = buffer.readShort();
|
|
String s = new String(buffer.readBytes(j).array(), Charsets.UTF_8);
|
|
return s;
|
|
}
|
|
*/
|
|
|
|
public static void validateAndSend(PacketBase capsule, EntityPlayerMP player){
|
|
if (!capsule.msg.isDisplayActive(PlayerTracker.INSTANCE.getPlayerSelectedTab(player))) return;
|
|
|
|
if (capsule.msg.canPlayerUseCommand(player))
|
|
PacketManager.sendToPlayer(capsule, player);
|
|
}
|
|
|
|
public static void sendPacketToAllSwing(PacketBase capsule){
|
|
for (EntityPlayerMP player : PlayerTracker.INSTANCE.playersSwing)
|
|
PacketManager.validateAndSend(capsule, player);
|
|
}
|
|
|
|
public static void sendChatMsg(String msg, EntityPlayerMP player){
|
|
PacketManager.sendToPlayer(new S02PacketChat(new ChatComponentText(msg)), player);
|
|
}
|
|
|
|
public static void splitAndSend(Message msg, ArrayList<? extends ISerializable> data, EntityPlayerMP player){
|
|
int i = 0;
|
|
while (i < data.size()){
|
|
validateAndSend(new NetDataList(msg, data.subList(i, Math.min(i + 500, data.size()))), player);
|
|
i += 500;
|
|
}
|
|
}
|
|
|
|
public static void sendFullUpdate(EntityPlayerMP player){
|
|
ArrayList<DataEntity> timingEntities = EntityManager.INSTANCE.getWorses(100);
|
|
ArrayList<DataBlockTileEntity> timingTileEnts = TileEntityManager.INSTANCE.getWorses(100);
|
|
//ArrayList<DataHandler> timingHandlers = TickHandlerManager.getCumulatedStatsServer();
|
|
ArrayList<StatsChunk> timingChunks = ChunkManager.INSTANCE.getTopChunks(100);
|
|
ArrayList<DataEntityPerClass> timingEntsClass = EntityManager.INSTANCE.getTotalPerClass();
|
|
ArrayList<DataBlockTileEntityPerClass> timingTEsClass = TileEntityManager.INSTANCE.getCumulativeTimingTileEntities();
|
|
|
|
DataTiming totalTimeTE = TileEntityManager.INSTANCE.getTotalUpdateTime();
|
|
DataTiming totalTimeEnt = EntityManager.INSTANCE.getTotalUpdateTime();
|
|
//DataTiming totalTimeHandler = TickHandlerManager.getTotalUpdateTime();
|
|
DataNetworkTick totalNetwork = new DataNetworkTick().fill();
|
|
DataBlockTick totalWorldTick = new DataBlockTick().fill();
|
|
|
|
ArrayList<DataEvent> timingEvents = new ArrayList<DataEvent>();
|
|
HashBasedTable<Class, String, DescriptiveStatistics> eventData = ((ProfilerEvent)ProfilerSection.EVENT_INVOKE.getProfiler()).data;
|
|
HashBasedTable<Class, String, String> eventMod = ((ProfilerEvent)ProfilerSection.EVENT_INVOKE.getProfiler()).dataMod;
|
|
for (Cell<Class, String, DescriptiveStatistics> cell : eventData.cellSet()){
|
|
timingEvents.add(new DataEvent().fill(cell, eventMod.get(cell.getRowKey(), cell.getColumnKey())));
|
|
}
|
|
|
|
ArrayList<DataEvent> timingTicks = new ArrayList<DataEvent>();
|
|
HashBasedTable<Class, String, DescriptiveStatistics> eventTickData = ((ProfilerEvent)ProfilerSection.EVENT_INVOKE.getProfiler()).dataTick;
|
|
HashBasedTable<Class, String, String> eventTickMod = ((ProfilerEvent)ProfilerSection.EVENT_INVOKE.getProfiler()).dataModTick;
|
|
for (Cell<Class, String, DescriptiveStatistics> cell : eventTickData.cellSet()){
|
|
timingTicks.add(new DataEvent().fill(cell, eventTickMod.get(cell.getRowKey(), cell.getColumnKey())));
|
|
}
|
|
|
|
PacketManager.validateAndSend(new NetDataList(Message.LIST_TIMING_HANDLERS, timingTicks), player);
|
|
PacketManager.validateAndSend(new NetDataList(Message.LIST_TIMING_ENTITIES, timingEntities), player);
|
|
PacketManager.validateAndSend(new NetDataList(Message.LIST_TIMING_TILEENTS, timingTileEnts), player);
|
|
PacketManager.validateAndSend(new NetDataList(Message.LIST_TIMING_TILEENTS_PER_CLASS, timingTEsClass), player);
|
|
PacketManager.validateAndSend(new NetDataList(Message.LIST_TIMING_CHUNK, timingChunks), player);
|
|
PacketManager.validateAndSend(new NetDataList(Message.LIST_TIMING_EVENTS, timingEvents), player);
|
|
PacketManager.validateAndSend(new NetDataList(Message.LIST_TIMING_ENTITIES_PER_CLASS, timingEntsClass), player);
|
|
PacketManager.validateAndSend(new NetDataValue(Message.VALUE_TIMING_TILEENTS, totalTimeTE), player);
|
|
PacketManager.validateAndSend(new NetDataValue(Message.VALUE_TIMING_ENTITIES, totalTimeEnt), player);
|
|
//PacketManager.validateAndSend(NetDataValue_OLD.create(Message.VALUE_TIMING_HANDLERS, totalTimeHandler), player);
|
|
PacketManager.validateAndSend(new NetDataValue(Message.VALUE_TIMING_WORLDTICK, totalWorldTick), player);
|
|
PacketManager.validateAndSend(new NetDataValue(Message.VALUE_TIMING_NETWORK, totalNetwork), player);
|
|
|
|
//PacketManager.validateAndSend(NetDataValue_OLD.create(Message.VALUE_AMOUNT_HANDLERS, new SerialInt(timingHandlers.size())), player);
|
|
|
|
PacketManager.validateAndSend(new NetDataValue(Message.STATUS_TIME_LAST_RUN, new SerialLong(ProfilerSection.timeStampLastRun)), player);
|
|
|
|
PacketManager.validateAndSend(new NetDataValue(Message.STATUS_ACCESS_LEVEL, new SerialInt(PlayerTracker.INSTANCE.getPlayerAccessLevel(player).ordinal())), player);
|
|
|
|
// This portion is to get the proper filtered amounts depending on the player preferences.
|
|
String name = player.getGameProfile().getName();
|
|
boolean filtered = false;
|
|
if (PlayerTracker.INSTANCE.filteredAmount.containsKey(name))
|
|
filtered = PlayerTracker.INSTANCE.filteredAmount.get(name);
|
|
ArrayList<AmountHolder> amountEntities = EntityManager.INSTANCE.getCumulativeEntities(filtered);
|
|
|
|
// Here we send a full update to the player
|
|
//OpisPacketHandler.validateAndSend(Packet_DataList.create(DataReq.LIST_AMOUNT_ENTITIES, amountEntities), player);
|
|
PacketManager.validateAndSend(new NetDataList(Message.LIST_AMOUNT_ENTITIES, amountEntities), player);
|
|
|
|
}
|
|
} |