java类net.minecraftforge.fml.common.network.handshake.NetworkDispatcher的实例源码

@Override
public List<NetworkDispatcher> selectNetworks(Object args, ChannelHandlerContext context, FMLProxyPacket packet)
{
    int dimension = (Integer)args;
    ImmutableList.Builder<NetworkDispatcher> builder = ImmutableList.builder();
    for (EntityPlayerMP player : FMLCommonHandler.instance().getMinecraftServerInstance().getPlayerList().getPlayerList())
    {
        if (dimension == player.dimension)
        {
            NetworkDispatcher dispatcher = player.connection.netManager.channel().attr(NetworkDispatcher.FML_DISPATCHER).get();
            // Null dispatchers may exist for fake players - skip them
            if (dispatcher != null) builder.add(dispatcher);
        }
    }
    return builder.build();
}

@Override
public List<NetworkDispatcher> selectNetworks(Object args, ChannelHandlerContext context, FMLProxyPacket packet)
{
    TargetPoint tp = (TargetPoint)args;
    ImmutableList.Builder<NetworkDispatcher> builder = ImmutableList.builder();
    for (EntityPlayerMP player : FMLCommonHandler.instance().getMinecraftServerInstance().getPlayerList().getPlayerList())
    {
        if (player.dimension == tp.dimension)
        {
            double d4 = tp.x - player.posX;
            double d5 = tp.y - player.posY;
            double d6 = tp.z - player.posZ;

            if (d4 * d4 + d5 * d5 + d6 * d6 < tp.range * tp.range)
            {
                NetworkDispatcher dispatcher = player.connection.netManager.channel().attr(NetworkDispatcher.FML_DISPATCHER).get();
                if (dispatcher != null) builder.add(dispatcher);
            }
        }
    }
    return builder.build();
}

@SubscribeEvent
public void onConnectionCreated(FMLNetworkEvent.ServerConnectionFromClientEvent event)
{
    JustEnoughDimensions.logInfo("FMLNetworkEvent.ServerConnectionFromClientEvent: Syncing dimension data to client");
    DimensionSyncPacket packet = new DimensionSyncPacket();
    packet.addDimensionData(DimensionConfig.instance().getRegisteredDimensions());

    FMLEmbeddedChannel channel = JustEnoughDimensions.channels.get(Side.SERVER);
    channel.attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.DISPATCHER);
    channel.attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(event.getManager().channel().attr(NetworkDispatcher.FML_DISPATCHER).get());
    channel.writeOutbound(packet);
}

public static List<FMLProxyPacket> forwardHandshake(CompleteHandshake push, NetworkDispatcher target, Side side)
{
    channelPair.get(side).attr(NetworkDispatcher.FML_DISPATCHER).set(target);
    channelPair.get(side).writeOutbound(push);

    ArrayList<FMLProxyPacket> list = new ArrayList<FMLProxyPacket>();
    for (Object o: channelPair.get(side).outboundMessages())
    {
        list.add((FMLProxyPacket)o);
    }
    channelPair.get(side).outboundMessages().clear();
    return list;
}

@Override
public void validateArgs(Object args)
{
    if (!(args instanceof NetworkDispatcher))
    {
        throw new RuntimeException("DISPATCHER expects a NetworkDispatcher");
    }
}

@Override
public List<NetworkDispatcher> selectNetworks(Object args, ChannelHandlerContext context, FMLProxyPacket packet)
{
    EntityPlayerMP player = (EntityPlayerMP) args;
    NetworkDispatcher dispatcher = (player == null || player instanceof FakePlayer) ? null : player.connection.netManager.channel().attr(NetworkDispatcher.FML_DISPATCHER).get();
    return dispatcher == null ? ImmutableList.<NetworkDispatcher>of() : ImmutableList.of(dispatcher);
}

@Override
public List<NetworkDispatcher> selectNetworks(Object args, ChannelHandlerContext context, FMLProxyPacket packet)
{
    ImmutableList.Builder<NetworkDispatcher> builder = ImmutableList.builder();
    for (EntityPlayerMP player : FMLCommonHandler.instance().getMinecraftServerInstance().getPlayerList().getPlayerList())
    {
        NetworkDispatcher dispatcher = player.connection.netManager.channel().attr(NetworkDispatcher.FML_DISPATCHER).get();
        if (dispatcher != null) builder.add(dispatcher);
    }
    return builder.build();
}

/**
 * INTERNAL fire a handshake to all channels
 * @param networkDispatcher The dispatcher firing
 * @param origin which side the dispatcher is on
 */
public void fireNetworkHandshake(NetworkDispatcher networkDispatcher, Side origin)
{
    NetworkHandshakeEstablished handshake = new NetworkHandshakeEstablished(networkDispatcher, networkDispatcher.getNetHandler(), origin);
    for (Entry<String, FMLEmbeddedChannel> channel : channels.get(origin).entrySet())
    {
        channel.getValue().attr(FMLOutboundHandler.FML_MESSAGETARGET).set(OutboundTarget.DISPATCHER);
        channel.getValue().attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(networkDispatcher);
        channel.getValue().pipeline().fireUserEventTriggered(handshake);
    }
}

@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {

    if (evt instanceof NetworkHandshakeEstablished) {
        INetHandler netHandler = ((NetworkDispatcher) ctx.channel().attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).get()).getNetHandler();
        if (netHandler instanceof NetHandlerPlayServer) {
            handler.handshakeReceived((NetHandlerPlayServer) netHandler);
        }
    } else {
        ctx.fireUserEventTriggered(evt);
    }
}

private void initLiason() {
    // We're fairly similar to PacketProxyingPlayer.initWrapping()
    networkManager = new CustomChannelNetworkManager(proxiedChannel, EnumPacketDirection.SERVERBOUND);
    this.playerNetServerHandler = new NetHandlerPlayServer(MinecraftServer.getServer(), networkManager, this);
    playerNetServerHandler.netManager.channel().attr(NetworkDispatcher.FML_DISPATCHER).set(new NetworkDispatcher(networkManager));
    //Compare net.minecraftforge.fml.common.network.FMLOutboundHandler.OutboundTarget.PLAYER.{...}.selectNetworks(Object, ChannelHandlerContext, FMLProxyPacket)
    playerNetServerHandler.netManager.setConnectionState(EnumConnectionState.PLAY);
}

void preinitWrapping() {
    playerNetServerHandler = new NetHandlerPlayServer(mcServer, networkManager, this);
    playerNetServerHandler.netManager.channel().attr(NetworkDispatcher.FML_DISPATCHER).set(new NetworkDispatcher(this.networkManager));
    //Compare net.minecraftforge.fml.common.network.FMLOutboundHandler.OutboundTarget.PLAYER.{...}.selectNetworks(Object, ChannelHandlerContext, FMLProxyPacket)
    playerNetServerHandler.netManager.setConnectionState(EnumConnectionState.PLAY);
    /* (misc notes here)
     * We don't need to touch NetworkDispatcher; we need a NetworkManager.
     *
     * NetworkManager.scheduleOutboundPacket is too early I think?
     * What we really want is its channel.
     */
}

public boolean queueUnwrappedPacket(EntityPlayer player, Object packetObj) {
    if (packetObj == null) return true;
    if (player == null) {
        if (packetObj instanceof C00PacketKeepAlive || packetObj instanceof S00PacketKeepAlive) {
            NORELEASE.fixme("Shouldn't this, like, not happen?");
            return true;
        }
        NORELEASE.println("No player to handle: " + packetObj + " " + packetObj.getClass().getSimpleName());
        return true;
    }
    if (player.worldObj.isRemote) return false;
    Packet packet = (Packet) packetObj;
    // May possibly need to inject the liason into things up higher, during reading. Somehow. Hopefulloy won't be needed.
    InteractionLiason liason = InteractionLiason.activeLiasons.get(player);
    if (liason == null) {
        if (!(packet instanceof C00PacketKeepAlive)) {
            // Seems our system isn't perfect. :/
            // Keepalives are generated from a different thread I guess.
            Hammer.logWarning("Liasonless wrapped packet: " + packet.getClass().getSimpleName() + " " + packet.toString());
        }
        return true;
    }
    NetHandlerPlayServer handler = liason.playerNetServerHandler;
    if (packet instanceof FMLProxyPacket) {
        FMLProxyPacket fml = (FMLProxyPacket) packet;
        NetworkDispatcher dispatcher = handler.netManager.channel().attr(NetworkDispatcher.FML_DISPATCHER).get();
        fml.setTarget(Side.CLIENT);
        fml.setDispatcher(dispatcher);
        if (fml.payload().readerIndex() != 0) {
            Core.logSevere("Packet double-processing detected! Channel: " + fml.channel());
            return true;
        }
    }
    packet.processPacket(handler);
    return true;
}

@Override
public void listDispatchers(Collection<EntityPlayerMP> players, Collection<NetworkDispatcher> result) {
    for (EntityPlayerMP player : players) {
        NetworkDispatcher dispatcher = NetUtils.getPlayerDispatcher(player);
        if (dispatcher != null) result.add(dispatcher);
        else Log.info("Trying to send message to disconnected player %s", player);
    }
}

@Override
public void listDispatchers(DimCoord coord, Collection<NetworkDispatcher> result) {
    WorldServer server = DimensionManager.getWorld(coord.dimension);

    Set<EntityPlayerMP> players = NetUtils.getPlayersWatchingBlock(server, coord.blockPos.getX(), coord.blockPos.getZ());

    for (EntityPlayerMP player : players) {
        NetworkDispatcher dispatcher = NetUtils.getPlayerDispatcher(player);
        result.add(dispatcher);
    }
}

@Override
public void listDispatchers(Entity entity, Collection<NetworkDispatcher> result) {
    Preconditions.checkArgument(entity.world instanceof WorldServer, "Invalid side");
    WorldServer server = (WorldServer)entity.world;
    Set<EntityPlayerMP> players = NetUtils.getPlayersWatchingEntity(server, entity);

    for (EntityPlayerMP player : players) {
        NetworkDispatcher dispatcher = NetUtils.getPlayerDispatcher(player);
        result.add(dispatcher);
    }
}

@Override
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
    if (!(msg instanceof FMLProxyPacket)) {
        ctx.write(msg);
        return;
    }

    final Channel channel = ctx.channel();

    final IPacketTargetSelector<?> target = channel.attr(MESSAGETARGET).get();
    if (target == null) {
        ctx.write(msg);
        return;
    }

    final FMLProxyPacket pkt = (FMLProxyPacket)msg;

    final Side channelSide = channel.attr(NetworkRegistry.CHANNEL_SOURCE).get();

    Preconditions.checkState(target.isAllowedOnSide(channelSide), "Packet not allowed on side");

    final String channelName = channel.attr(NetworkRegistry.FML_CHANNEL).get();

    Object arg = channel.attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).get();

    try {
        final Collection<NetworkDispatcher> dispatchers = getDispatchers(target, arg);
        for (NetworkDispatcher dispatcher : dispatchers)
            dispatcher.sendProxy(pkt);

    } catch (Throwable t) {

        throw new IllegalStateException(String.format(
                "Failed to select and send message (selector %s, arg: %s, channel: %s, side: %s)",
                target, arg, channelName, channelSide), t);
    }

}

public NetworkHandshakeEstablished(NetworkDispatcher dispatcher, INetHandler netHandler, Side origin)
{
    this.netHandler = netHandler;
    this.dispatcher = dispatcher;
    this.side = origin;
}

public void setDispatcher(NetworkDispatcher networkDispatcher)
{
    this.dispatcher = networkDispatcher;
}

public NetworkDispatcher getDispatcher()
{
    return this.dispatcher;
}

@Override
protected void channelRead0(ChannelHandlerContext ctx, CompleteHandshake msg) throws Exception
{
    NetworkDispatcher dispatcher = ctx.channel().attr(NetworkDispatcher.FML_DISPATCHER).getAndRemove();
    dispatcher.completeHandshake(msg.target);
}

public static void fmlServerHandshake(PlayerList scm, NetworkManager manager, EntityPlayerMP player)
{
    NetworkDispatcher dispatcher = NetworkDispatcher.allocAndSet(manager, scm);
    dispatcher.serverToClientHandshake(player);
}

public static void fmlClientHandshake(NetworkManager networkManager)
{
    NetworkDispatcher dispatcher = NetworkDispatcher.allocAndSet(networkManager);
    dispatcher.clientToServerHandshake();
}

@Override
public List<NetworkDispatcher> selectNetworks(Object args, ChannelHandlerContext context, FMLProxyPacket packet)
{
    return null;
}

@Override
public List<NetworkDispatcher> selectNetworks(Object args, ChannelHandlerContext context, FMLProxyPacket packet)
{
    return ImmutableList.of((NetworkDispatcher)args);
}

@Override
public List<NetworkDispatcher> selectNetworks(Object args, ChannelHandlerContext context, FMLProxyPacket packet)
{
    return ImmutableList.of(packet.getDispatcher());
}

@Override
public List<NetworkDispatcher> selectNetworks(Object args, ChannelHandlerContext context, FMLProxyPacket packet)
{
    NetworkManager clientConnection = FMLCommonHandler.instance().getClientToServerNetworkManager();
    return clientConnection == null || clientConnection.channel().attr(NetworkDispatcher.FML_DISPATCHER).get() == null ? ImmutableList.<NetworkDispatcher>of() : ImmutableList.of(clientConnection.channel().attr(NetworkDispatcher.FML_DISPATCHER).get());
}

@Override
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception
{
    if (!(msg instanceof FMLProxyPacket))
    {
        return;
    }
    FMLProxyPacket pkt = (FMLProxyPacket) msg;
    OutboundTarget outboundTarget;
    Object args = null;
    NetworkDispatcher dispatcher = ctx.channel().attr(NetworkDispatcher.FML_DISPATCHER).get();
    // INTERNAL message callback - let it pass out
    if (dispatcher != null)
    {
        ctx.write(msg, promise);
        return;
    }

    outboundTarget = ctx.channel().attr(FML_MESSAGETARGET).get();
    Side channelSide = ctx.channel().attr(NetworkRegistry.CHANNEL_SOURCE).get();
    if (outboundTarget != null && outboundTarget.allowed.contains(channelSide))
    {
        args = ctx.channel().attr(FML_MESSAGETARGETARGS).get();
        outboundTarget.validateArgs(args);
    }
    else if (channelSide == Side.CLIENT)
    {
        outboundTarget = OutboundTarget.TOSERVER;
    }
    else
    {
        throw new FMLNetworkException("Packet arrived at the outbound handler without a valid target!");
    }

    List<NetworkDispatcher> dispatchers = outboundTarget.selectNetworks(args, ctx, pkt);

    // This will drop the messages into the output queue at the embedded channel
    if (dispatchers == null)
    {
        ctx.write(msg, promise);
        return;
    }
    for (NetworkDispatcher targetDispatcher : dispatchers)
    {
        targetDispatcher.sendProxy((FMLProxyPacket) msg);
    }
}

private static <T> Collection<NetworkDispatcher> getDispatchers(IPacketTargetSelector<T> target, Object arg) {
    final Collection<NetworkDispatcher> output = Lists.newArrayList();
    target.listDispatchers(target.castArg(arg), output);
    return output;
}

public static NetworkDispatcher getPlayerDispatcher(EntityPlayerMP player) {
    NetworkDispatcher dispatcher = player.connection.netManager.channel().attr(NetworkDispatcher.FML_DISPATCHER).get();
    return dispatcher;
}

public abstract List<NetworkDispatcher> selectNetworks(Object args, ChannelHandlerContext context, FMLProxyPacket packet);