import li.cil.oc.api.network.Node; //导入依赖的package包/类
@Override
public void readFromNBT(final NBTTagCompound nbt) {
    super.readFromNBT(nbt);
    int index = 0;
    for (Node node : nodes) {
        // The host check may be superfluous for you. It's just there to allow
        // some special cases, where getNode() returns some node managed by
        // some other instance (for example when you have multiple internal
        // nodes in this tile entity).
        if (node != null && node.host() == this) {
            // This restores the node's address, which is required for networks
            // to continue working without interruption across loads. If the
            // node is a power connector this is also required to restore the
            // internal energy buffer of the node.
            node.load(nbt.getCompoundTag("oc:node" + index));
        }
        ++index;
    }
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
private Object[] hardwareInvoke(String address, String method, Object[] params) throws Exception {
	if(method.equals("_getMethods")) {
		Node node = machine.node().network().node(address);
		if(node == null || !(node instanceof Component)) return new Object[]{null, "node disappeared?"};
		Component component = (Component)node;
		TreeMap<Object, Object> ret = new TreeMap<Object, Object>();
		for(String name : component.methods()) {
			Callback cb = component.annotation(name);
			if(cb != null) {
				TreeMap<Object, Object> map = new TreeMap<Object, Object>();
				map.put("direct", cb.direct());
				map.put("getter", cb.getter());
				map.put("setter", cb.setter());
				ret.put(name, map);
			}
		}
		return new Object[]{ret};
	}
	else return machine.invoke(address, method, params);
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
@Optional.Method(modid = "OpenComputers")
@Override
public Node sidedNode(ForgeDirection side) {
	if (worldObj.isRemote) {
		return null;
	}

	Pocket p = getPocket();
	if (p == null) {
		return null;
	}

	switch (p.getFlowState(side)) {
		case ENERGY:
			TileEntity te = getFrameConnectorNeighborTileEntity(side);
			if (te instanceof SidedEnvironment) {
				return ((SidedEnvironment) te).sidedNode(side);
			} else if (te instanceof Environment) {
				return ((Environment) te).node();
			}
			return null;
		default:
			return null;
	}
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
public void updateVolume()
{
	for (int x=0; x<mWidth; x++)
	{
		for (int y=0; y<mHeight; y++)
		{
			TileEntityExternalMonitor rtile = (TileEntityExternalMonitor) worldObj.getTileEntity(getXFromOrient(x-mX,y-mY), getYFromOrient(x-mX,y-mY), getZFromOrient(x-mX,y-mY));
			rtile.r = r;
			rtile.g = g;
			rtile.b = b;
			rtile.mX = x;
			rtile.mY = y;
			rtile.mWidth = mWidth;
			rtile.mHeight = mHeight;
			if (rtile.mon != mon && rtile.mon != null)
			{
				for (Node n : rtile.mon.node().network().nodes(rtile.mon.node()))
				{
					n.network().disconnect(n, rtile.mon.node());
				}
			}
			rtile.mon = mon;
		}
	}
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
@Test
public void testNodeConnectivity() throws Exception {
	setupOpenComputersApiMock();

	ICodeGenerator generator = new PeripheralCodeGenerator();

	Map<String, IMethodExecutor> methods = Maps.newHashMap();
	Class<? extends ManagedEnvironment> cls = generateClass("TestClass\u2654", SemiAwareTargetClass.class, ImmutableSet.<Class<?>> of(), methods, generator);

	final SemiAwareTargetClass target = mock(SemiAwareTargetClass.class);
	ManagedEnvironment o = cls.getConstructor(SemiAwareTargetClass.class).newInstance(target);

	Node node = mock(Node.class);

	o.onConnect(node);
	verifyOcSpecificConnectCall(target, node);

	o.onDisconnect(node);
	verifyOcSpecificDisconnectCall(target, node);
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
@Override
public void onChunkUnload() {
    super.onChunkUnload();
    // Make sure to remove the node from its network when its environment,
    // meaning this tile entity, gets unloaded.
    for (Node node : nodes) {
        if (node != null) node.remove();
    }
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
@Override
public void invalidate() {
    super.invalidate();
    // Make sure to remove the node from its network when its environment,
    // meaning this tile entity, gets unloaded.
    for (Node node : nodes) {
        if (node != null) node.remove();
    }
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
@Override
public NBTTagCompound writeToNBT(NBTTagCompound nbt) {
    super.writeToNBT(nbt);
    int index = 0;
    for (Node node : nodes) {
        // See readFromNBT() regarding host check.
        if (node != null && node.host() == this) {
            final NBTTagCompound nodeNbt = new NBTTagCompound();
            node.save(nodeNbt);
            nbt.setTag("oc:node" + index, nodeNbt);
        }
        ++index;
    }
    return nbt;
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
@Override
public void onConnect(final Node node) {
    // This is called when the call to Network.joinOrCreateNetwork(this) in
    // updateEntity was successful, in which case `node == this`.
    // This is also called for any other node that gets connected to the
    // network our node is in, in which case `node` is the added node.
    // If our node is added to an existing network, this is called for each
    // node already in said network.
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
@Override
public void onDisconnect(final Node node) {
    // This is called when this node is removed from its network when the
    // tile entity is removed from the world (see onChunkUnload() and
    // invalidate()), in which case `node == this`.
    // This is also called for each other node that gets removed from the
    // network our node is in, in which case `node` is the removed node.
    // If a net-split occurs this is called for each node that is no longer
    // connected to our node.
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
@Override
public void writeToNBT(NBTTagCompound nbt) {
    super.writeToNBT(nbt);
    int index = 0;
    for (Node node : nodes) {
        // See readFromNBT() regarding host check.
        if (node != null && node.host() == this) {
            final NBTTagCompound nodeNbt = new NBTTagCompound();
            node.save(nodeNbt);
            nbt.setTag("oc:node" + index, nodeNbt);
        }
        ++index;
    }
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
@Override
public Object[] invoke(String address, String method, Object[] args)
		throws Exception {
	Node n = network.node(address);
	if (n == null || !(n instanceof Component)) {
		throw new NoSuchMethodError();
	}
	return ((Component) n).invoke(method, this, args);
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
List<SimComponent> getComponents() {
	List<SimComponent> components = new ArrayList<SimComponent>();
	for (Node n : network.nodes()) {
		if (n instanceof SimComponent) {
			components.add((SimComponent) n);
		}
	}

	return components;
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
public static void invalidate(final SimpleComponentImpl self) {
    self.invalidate_OpenComputers();
    final Node node = node(self);
    if (node != null) {
        node.remove();
        nodes.remove(self);
    }
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
public static void onChunkUnload(final SimpleComponentImpl self) {
    self.onChunkUnload_OpenComputers();
    final Node node = node(self);
    if (node != null) {
        node.remove();
        nodes.remove(self);
    }
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
public static void readFromNBT(final SimpleComponentImpl self, NBTTagCompound nbt) {
    self.readFromNBT_OpenComputers(nbt);
    final Node node = node(self);
    if (node != null) {
        node.load(nbt.getCompoundTag("oc:node"));
    }
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
public static void writeToNBT(final SimpleComponentImpl self, NBTTagCompound nbt) {
    self.writeToNBT_OpenComputers(nbt);
    final Node node = node(self);
    if (node != null) {
        final NBTTagCompound nodeNbt = new NBTTagCompound();
        node.save(nodeNbt);
        nbt.setTag("oc:node", nodeNbt);
    }
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
public static double distance( Node n1, Node n2 ){
    TileEntity te1 = (  TileEntity  ) n1.host(  );
    TileEntity te2 = (  TileEntity  ) n2.host(  );
    if(  te1 != null && te2 != null  ){
        double dx = Math.pow(  te2.xCoord - te1.xCoord, 2  );
        double dy = Math.pow(  te2.yCoord - te1.yCoord, 2  );
        double dz = Math.pow(  te2.zCoord - te1.zCoord, 2  );
        double res = dx + dy + dz;
        return Math.abs(  Math.sqrt(  res  ) );
    }
    return 0;
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
@Optional.Method(modid = "OpenComputers")
@Override
public Node sidedNode(ForgeDirection side) {
	if (worldObj.isRemote) {
		return null;
	}

	Pocket p = getPocket();
	if (p == null) {
		return null;
	}

	side = side.getOpposite();

	switch (p.getFlowState(side)) {
		case ENERGY:
			TileEntity te = getDimPocketNeighbourTileEntity(side);
			if (te instanceof SidedEnvironment) {
				return ((SidedEnvironment) te).sidedNode(side);
			} else if (te instanceof Environment) {
				return ((Environment) te).node();
			}
			return null;
		default:
			return null;
	}
}
 

import li.cil.oc.api.network.Node; //导入依赖的package包/类
@Override
public void onConnect(Node node)
{
	if (!initd)
		init();
	if (node.host() instanceof Context)
	{
		node.connect(romGX.node());
		if (monitor != null) node.connect(monitor.node());
	}
}