[1.18.2][Fabric]在自己的Mod里添加线缆网络！ - 编程开发

SPE__HaiKuo

本帖最后由 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);
}

复制代码

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

实际效果

后续

2536195417

大佬求教开服务器（来自萌新最后的抵抗）

离殇雪

我是来捧场的（

悲灬风

我是来捧场的 )

幽月琉璃

好东西，进我收藏夹吃灰

~~虽然说我写的是1.16.5forge，并且看到GUI跟方块实体那边感觉太复杂不想学直接咕了，但应该认真学了基础思路也能套上去的~~

Saponetin

《关于我在MCBBS学数据结构那些事》

8093133309

我是来喊“大佬66666”

XYZ_2022

我是来捧场的 )

luck98k

我来捧场的

17806697836

大佬666，我是来捧场的

2790388266

6666666666

干爽的稀饭

学到了！！!!!!!

xiaoyuyuy

6666666666666666666666666

QAQ琉璃

我是来捧场的（

记得开心1点

大佬辛苦了

天昌俑度

见识＋1，对萌新很有帮助

三浩Shao

jgsjyskur

66666666666

恐龙君123

回到开头，我很激动

851382495

虽然看不懂但是感觉很牛逼

回忆你好

我是来捧场的 )

Adjlldxy

我是来捧场的 )

liurrrt

加油，服务器要钱运营，而且服务器主机有好坏之分，网上的大佬一堆，b站上应该就有

wdawsd

阿坝阿坝阿坝

shuaiqidewo121

MCBBS有你更精彩~

熱吻丶

11111111111111111111111111111111111111111111111111111111

星蚀

感谢楼主分享的东西我非常喜欢

DaVK9

非常棒，mcbbs有你更精彩~继续努力

wzh20100421

非常好玩

星蚀

感谢作者分享

1602552896

好强！！！！！！

须臾泡影

我是来捧场的66666

星蚀

感谢贴主分享，很有帮助

jijimaomao233

我是来捧场的awa

xiaochao54199

666tailihaile

就是个人满级

进我收藏夹吃灰

擅长摆烂真君

太牛逼了学会了谢谢了

擅长摆烂真君

我是来捧场的 )

唔的天

6666666666

2539808958

好强呀！

juece

好棒好棒！

Eicy

看见bfs就知道这有多重量级了

TioMor

看了好久看不懂

Gxk20021207

MCBBS有你更精彩~

shd18

高呼666！

小小啊d

啊福娃福娃FEw若非威风威风

怒火小米

12345678910

模组唐三

@SPE__HaiKuo
能不能麻烦把那个Tire01发一下，我网上找不到

阿库娅的小麦铺

MCBBS有你更精彩~

粽子G丶

6666666666666

下一页最后一页