[1.18.2][Fabric]在自己的Mod里添加线缆网络！

本帖最后由 SPE__HaiKuo 于 2022-9-18 22:47 编辑

看到AE、TR、EIO等等的管道网络，是否十分心动，也想要在自己的Mod里面添加属于自己的线缆网络？
那么这篇教程将会阐述如何在1.18.2 Fabric中添加一个 简单、可拓展、可移植 的线缆网络！
本教程为进阶教程，不包含基础方面如如何添加 Block 和 BlockEntity 等，基础教程请移步 Fabric Wiki
本教程中具体实现和Fabric特性关系不大，用Forge只需稍作修改即可！
前期准备

构建网络类

我们先将网络从Minecraft中抽离出来。
其实 网络也就只是一种数据结构——图 ，这和是不是在Minecraft中没有关系。
因此，我们可以先脱离框架，构建网络类。
对于网络，可以构建一个 Network 类，对于网络的每个结点，可以构建一个 NetworkNode 类。
一个 Network 中包含许多个 NetworkNode 结点，因此用 Set<NetworkNode> 来存储各个结点。
具体代码如下：

public class Network {
//为每个网络分配一个id
private int id;
//存储网络的各个结点
private Set<NetworkNode> nodes;
public Network(int id) {
this.id = id;
this.nodes = new HashSet<>();
}
//获取网络id
public int getId() {
return id;
}
//获取该网络的所有结点
public Set<NetworkNode> getNodes() {
return nodes;
}
//增加结点
public void addNode(NetworkNode node) {
nodes.add(node);
}
//移除结点
public void removeNode(NetworkNode node) {
nodes.remove(node);
}
//摧毁网络，将网络各结点“放生”
public void destroy() {
for (NetworkNode node : nodes) {
node.setNetwork(null);
}
nodes.clear();
}
}

复制代码

public class NetworkNode {
//为每个结点分配一个id
private int id;
//结点所在的网络
private Network network;
//获取结点id
public int getId() {
return id;
}
//获取结点所在的网络
public Network getNetwork() {
return network;
}
//设置结点所在的网络
public void setNetwork(Network network) {
this.network = network;
}
}

复制代码

接下来就要将网络类和框架结合起来，桥梁为 NetworkNode 和 BaseBlockEntity 。
在 NetworkNode 中添加：

//存储结点所在的BlockEntity
private BaseBlockEntity blockEntity;
//构造函数
public NetworkNode(int id, BaseBlockEntity blockEntity) {
this.id = id;
this.blockEntity = blockEntity;
this.network = null;
}
//获取结点所在位置
public BlockPos getPos() {
return blockEntity.getPos();
}
//获取结点所在的BlockEntity
public BaseBlockEntity getBlockEntity() {
return blockEntity;
}

复制代码

在 BaseBlockEntity 中添加：

//存储BlockEntity对应的结点
private NetworkNode networkNode;
//设置BlockEntity对应的结点
public void setNetworkNode(NetworkNode networkNode) {
this.networkNode = networkNode;
}
//获取BlockEntity对应的结点
public NetworkNode getNetworkNode() {
return networkNode;
}

复制代码

这样网络和方块之间就能互相访问了。

构建网络相关服务

我们采用集中式而非并行式的方法来管理网络和网络寻路，需要两个服务，一个是管理网络的服务 NetworkService ，另一个是网络寻路的服务 PathService 。所有服务都在服务端运行。
集中式服务管理经常用到以下事件：

ServerLifecycleEvents.SERVER_STARTING ：服务端启动；
ServerLifecycleEvents.SERVER_STOPPED ：服务端关闭；
ServerBlockEntityEvents.BLOCK_ENTITY_LOAD ：方块实体加载；
ServerBlockEntityEvents.BLOCK_ENTITY_UNLOAD ：方块实体卸载；
ServerTickEvents.END_SERVER_TICK ：服务端TICK结束时。

上述事件具体触发时间可以去翻阅Fabric文档或者查看源码。
因为要监听事件，所以服务要注册事件，就可以继承Fabric的 ModInitializer 接口，将事件注册放在 onInitialize 中。

NetworkService
我们先构建 NetworkService ，用于管理网络：

public class NetworkService implements ModInitializer {
//日志
private static final Logger LOGGER = LogUtils.getLogger();
//记录已经用过的网络ID和结点ID
private Trie01 networkID, nodeID;
//管理网络
private Set<Network> networks;
//创建一个静态实例
public static final NetworkService INSTANCE = new NetworkService();
//注册事件
@Override
public void onInitialize() {
ServerLifecycleEvents.SERVER_STARTING.register(this::onServerStarting);
ServerLifecycleEvents.SERVER_STOPPED.register(this::onServerStopped);
}
//服务端启动时，初始化
private void onServerStarting(MinecraftServer server) {
networkID = new Trie01();
nodeID = new Trie01();
networks = new HashSet<>();
}
//服务端关闭时，清空
private void onServerStopped(MinecraftServer server) {
networkID.clear();
nodeID.clear();
networks.clear();
}
//创建网络
public Network createNetwork() {
Network network = new Network(networkID.mexAndInsert());
networks.add(network);
LOGGER.info("Create network#{}", network.getId());
return network;
}
//创建网络节点
public NetworkNode createNetworkNode(BaseBlockEntity blockEntity) {
NetworkNode node = new NetworkNode(nodeID.mexAndInsert(), blockEntity);
blockEntity.setNetworkNode(node);
LOGGER.info("Create network node#{}", node.getId());
return node;
}
//删除网络
public void removeNetwork(Network network) {
LOGGER.info("Remove network#{}", network.getId());
networkID.remove(network.getId());
networks.remove(network);
network.destroy();
}
//删除网络节点
public void removeNetworkNode(NetworkNode node) {
LOGGER.info("Remove network node#{}", node.getId());
if (node.getNetwork() != null) removeNodeInNetwork(node, node.getNetwork());
nodeID.remove(node.getId());
}
//将结点node添加到网络network中
public void addNodeToNetwork(NetworkNode node, Network network) {
network.addNode(node);
node.setNetwork(network);
}
//从网络network中移除结点node
public void removeNodeInNetwork(NetworkNode node, Network network) {
network.removeNode(node);
node.setNetwork(null);
}
//获取所有网络
public Set<Network> getNetworks() {
return networks;
}
}

复制代码

LOGGER 用于打印日志调试，可以去除；
为了找到一个最小的没用过的自然数（mex）作为ID分配，需要用到一种数据结构——01字典树 Trie01 ，可以快速查找mex，具体算法可以在网上搜索，因为不是重点，所以这里不做阐述。如果要简单地实现可以不用求mex，直接用 int 进行累加即可；
INSTANCE 为服务的静态实例，需要在Mod的初始化过程 onInitialize 中调用 NetworkService.INSTANCE.onInitialize() 进行事件注册。后续要进行服务调用则直接调用 NetworkSerive.INSTANCE 进行，如创建网络就调用 Network network = NetworkService.INSTANCE.createNetwork() 即可。

PathService
之后再构建 PathService ，用来网络寻路：

public class PathService implements ModInitializer {
//日志
private static final Logger LOGGER = LogUtils.getLogger();
//创建一个静态实例
public static final PathService INSTANCE = new PathService();
//注册时间
@Override
public void onInitialize() {
ServerBlockEntityEvents.BLOCK_ENTITY_LOAD.register(this::onNIOBlockEntityLoad);
ServerBlockEntityEvents.BLOCK_ENTITY_UNLOAD.register(this::onNIOBlockEntityUnload);
ServerTickEvents.END_SERVER_TICK.register(this::onServerEndTick);
ServerLifecycleEvents.SERVER_STARTING.register(this::onServerStarting);
}
//服务端启动时，初始化
private void onServerStarting(MinecraftServer server) {
//寻路相关，后文介绍
}
//方块加载时，创捷网络结点
private void onBlockEntityLoad(BlockEntity blockEntity, ServerWorld world) {
if (blockEntity instanceof BaseBlockEntity BE) {
NNetworkNode node = NetworkService.INSTANCE.createNetworkNode(BE);
//寻路相关，后文介绍
}
}
//方块卸载时，删除网络结点和所属网络
private void onBlockEntityUnload(BlockEntity blockEntity, ServerWorld world) {
if (blockEntity instanceof BaseBlockEntity BE) {
NNetwork network = BE.getNetworkNode().getNetwork();
NetworkService.INSTANCE.removeNetworkNode(BE.getNetworkNode());
if (network != null) {
//寻路相关，后文介绍
NetworkService.INSTANCE.removeNetwork(network);
}
}
}
//服务端TICK结束时
private void onServerEndTick(MinecraftServer server) {
//进行寻路，后文介绍
}
}

复制代码

LOGGER 用于打印日志调试，可以去除；
寻路相关将在下一个部分介绍；
INSTANCE 为服务的静态实例，需要在Mod的初始化过程 onInitialize 中调用 PathService.INSTANCE.onInitialize() 进行事件注册。

建立网络

建立网络其实就是一个图遍历问题： 将所有相邻的网络结点存放在同一个网络之中 。
那么图遍历问题的一个经典做法就是 广度优先遍历（BFS） ，这里我们也就用BFS来建立网络。
看到这里的小伙伴们可能就会有疑问： onServerEndTick 是用来干什么的呢？
其实方块加载/卸载都是在一个TICK中的异步过程，而Minecraft框架提供的 ServerTickEvents.END_SERVER_TICK 则是在一个TICK结束时的同步过程。
因此，我们用一个队列来存储异步过程中需要进行寻路的结点，在同步过程中进行寻路处理即可！
声明一个处理队列，并在服务端启动时进行初始化：

private Queue<NetworkNode> queue;
private void onServerStarting(MinecraftServer server) {
this.queue = new ArrayDeque<>();
}

复制代码

之后我们需要在方块加载/卸载时将需要处理的结点放入处理队列中：

private void onBlockEntityLoad(BlockEntity blockEntity, ServerWorld world) {
if (blockEntity instanceof BaseBlockEntity BE) {
NNetworkNode node = NetworkService.INSTANCE.createNetworkNode(BE);
//新建的网络结点放入处理队列中
queue.add(node);
}
}
private void onBlockEntityUnload(BlockEntity blockEntity, ServerWorld world) {
if (blockEntity instanceof BaseBlockEntity BE) {
NNetwork network = BE.getNetworkNode().getNetwork();
NetworkService.INSTANCE.removeNetworkNode(BE.getNetworkNode());
if (network != null) {
//网络已损坏，需要将所拥有的全部结点重新处理，放入处理队列中
queue.addAll(network.getNodes());
NetworkService.INSTANCE.removeNetwork(network);
}
}
}

复制代码

接下来就是最重要的寻路过程了，下面先放张图让大家理解一下：

由于方块实体一加载就全部放入队列中，因此没有不在队列中的结点；
图中黑点不一定是同一轮加入到队列中的结点，可能是之前就已经处理完构建好网络的结点；
每轮都需要保证队列所有结点均需处理完。

每次对从队列中拿出来的正在处理的结点具体处理步骤如下：

判断结点所在位置是否加载，如果未加载则直接跳过 （ World.getBlockEntity 会强制加载所在位置方块实体，需要先判断是否加载，否则会导致加载和卸载事件反复进行！）；
由于队列中的结点不一定存在所属网络，所以如果结点所属网络为空则创建一个所属网络；
对于每个可能的连接方向：
- 判断对应方向的位置是否加载，如果未加载则跳过；
- 判断对应方向的位置的方块实体是否是网络方块实体，不是则跳过；
- 获取对应网络方块实体的网络结点，判断其所属网络：
  - 如果没有所属网络，则将其加入正在处理的结点的网络，并将其加入到处理队列中；
  - 如果有所属网络，则将这两个网络合并（后文会阐述如何合并）。

具体代码如下：

private void onServerEndTick(MinecraftServer server) {
boolean flag = false;
while (!queue.isEmpty()) {
flag = true;
NetworkNode cur = queue.remove();
World world = cur.getBlockEntity().getWorld();
//如果未加载则直接跳过
if (!world.isPosLoaded(cur.getPos().getX(), cur.getPos().getZ())) continue;
if (cur.getNetwork() == null) {
//如果没有所属网络则创建一个
Network network = NetworkService.INSTANCE.createNetwork();
NetworkService.INSTANCE.addNodeToNetwork(cur, network);
}
Network curNetwork = cur.getNetwork();
for (Direction direction : cur.getPossibleConnection()) {
BlockPos pos = cur.getPos().offset(direction);
if (world.isPosLoaded(pos.getX(), pos.getZ()) && world.getBlockEntity(pos) instanceof BaseBlockEntity BE) {
NNetworkNode next = BE.getNetworkNode();
NNetwork nextNetwork = next.getNetwork();
if (nextNetwork == null) {
//将结点加入到网络中
NetworkService.INSTANCE.addNodeToNetwork(next, curNetwork);
queue.add(next);
} else if (curNetwork != nextNetwork) {
//合并网络
NetworkService.INSTANCE.mergeNetwork(curNetwork, nextNetwork);
//记得更新正在处理的所属网络！
curNetwork = cur.getNetwork();
}
}
}
}
//打印调试信息
if (flag) {
LOGGER.info("Path finding finish");
for (Network network : NetworkService.INSTANCE.getNetworks()) {
LOGGER.info("Network#{}:", network.getId());
for (NetworkNode node : network.getNodes()) {
BlockPos pos = node.getPos();
LOGGER.info("Node#{}: {}, {}, {}", node.getId(), pos.getX(), pos.getY(), pos.getZ());
}
}
}
}

复制代码

方块加载事件处理保证了每个网络方块实体都拥有一个网络节点；
所有需要处理的结点都在处理队列中保证了合并网络后无需更新处理队列。

这段代码中有两个没有出现过的函数，一个是 getPossibleConnection ，另一个是 mergeNetwork 。
我们先关注 getPossibleConnection ，即所有可能的连接。
在 BaseBlockEntity 中添加：

public List<Direction> getPossibleConnection() {
return Arrays.asList(Direction.values());
}
public boolean canConnect(Direction direction) {
return getPossibleConnection().contains(direction);
}

复制代码

具体子类的处理可以重载 getPossibleConnection 函数来自定义所有可能的连接。
在 NetworkNode 中添加：

public List<Direction> getPossibleConnection() {
return blockEntity.getPossibleConnection();
}

复制代码

这样就定义完了所有可能的连接。
最后是 mergeNetwork ，即合并两个网络，这里采用一种启发式的方法来高效合并两个网络，即将小的网络合并到大的网络。
在 Network 中添加：

//调用时保证n1大小大于n2
private static Network mergeInPrior(Network n1, Network n2) {
//将n2的所有结点的所属网络设置为n1
for (NetworkNode node : n2.nodes) {
node.setNetwork(n1);
}
//将n2的所有节点加入到n1中
n1.nodes.addAll(n2.nodes);
//清空n2
n2.nodes.clear();
return n1;
}
//按照大小合并网络
public static Network merge(Network n1, Network n2) {
if (n1.nodes.size() >= n2.nodes.size()) return mergeInPrior(n1, n2);
else return mergeInPrior(n2, n1);
}

复制代码

在 NetworkService 中添加：

public void mergeNetwork(Network n1, Network n2) {
//n3为合并后的网络
Network n3 = Network.merge(n1, n2);
//将被合并的网络删除
if (n3 == n1) removeNetwork(n2);
else removeNetwork(n1);
}

复制代码

至此，你就可以构建自己的网络了！如果对过程不是很理解可以看下图加深一下理解：

实际效果

后续

[1.18.2][Fabric]在自己的Mod里添加线缆网络！

回复: