AutoCartSystem
构建自动铺设轨道的铁路网络。 AutoCartSystem 将矿车转变为一种能够自动铺设轨道、自动挖掘、自动架设桥梁且可驾驶的列车系统——让通过铁路前往远方比步行更快。
在轨道上放置矿车,它们会自动铺设轨道、开凿隧道、跨越深渊、运输资源并设置信号站。然后将它们连接成列车,并使用真正的引擎进行驾驶。
需要 Minecraft 26.x 或更高版本(Paper)
为什么?
使用矿车开采并将资源运回基地的想法很诱人,但最终并不实用。建造铁路网络所需的工作量远远超过直接徒步开凿矿坑并走回来的难度。
开凿孔洞、搭建桥梁、铺设轨道以及添加动力轨所需的准备工作非常繁琐。然后你开始在矿车附近进行露天开采,不知不觉间你就已经距离矿车数千格远,而所用时间却远少于仅仅将矿车运送到那里的时间。这个插件旨在解决这些问题以及其他更多问题。
功能
- 车厢耦合与列车 — 将多个车厢耦合为识别出的列车(最长可达 20 节)。每种原版和 ACS 车厢类型都有对应的耦合变体。
- 自动铺轨器 — 从自身的存储中取出铁轨,在列车前方铺设轨道,使轨道随行进过程自动延伸。
- 自动架桥器 — 用存储中的方块填充轨道下方的空隙;支持用于图案化桥梁的不同方块类型。
- 钻头车厢 — 以可配置的图案(1x2、2x1、2x2 右/左、3x2、3x3)在列车前方进行挖掘,消耗存储中的镐子。
- 引擎车厢 — 一个更快、更智能的熔炉车厢,可以拉动任意大小的列车爬上任何山坡,并且可以由玩家骑乘连接的驾驶员车厢来驾驶。它保持所在区块加载状态,以确保列车持续移动。
- 驾驶员车厢 — 专用的可骑乘车厢,允许骑手控制列车,并让你左右转向轨道/钻头。
- 长漏斗 — 可将物品推入距离漏斗出口端最多 20 格内的任何箱子,而不仅仅是相邻的方块。
- 智能告示牌 —
[ACS:HOPPER] 物品过滤器、[ACS:TRASH] 虚空箱以及 [ACS:SIGNAL] 列车信号,这些信号会在条件(箱子空/满、计时器、轨道畅通)满足之前减缓并停止自动驱动的列车。
快速开始
-
将 AutoCartSystem .jar 文件放入服务器的 plugins/ 文件夹中。
-
启动(或重启)你的 Paper 26.x+ 服务器。首次运行时会自动生成默认的 config.yml。
-
给自己一些车厢并将它们放置在轨道上:
/acs give engine
/acs give track_layer 64
/acs give drill true
-
将它们耦合起来,给引擎加燃料,跳进后面的车厢,向前行驶。
ACS 车厢不是创造模式菜单中的物品——创造模式库存中找不到新物品。通过合成(参见 合成配方)或使用 /acs give <type>(默认 OP 权限)获取。
填充与配置车厢
功能性车厢(引擎、钻头、铺轨器、架桥器)各自携带自己的存储空间。潜行 + 右键点击已放置的车厢以打开其存储 GUI:
- 引擎 — 投入燃料(煤炭、煤块、 lava 桶等)。引擎是一个你无法坐进去的熔炉矿车;它由连接的驾驶员车厢驱动。(不潜行时右键无效——它不接受像原版熔炉矿车那样手动喂食燃料的方式。)
- 钻头 — 投入镐子;点击 GUI 中的指南针按钮以循环切换挖掘图案(1x2 → 2x2 右 → 2x2 左 → 3x2 → 3x3)。
- 铺轨器 — 投入铁轨。架桥器 — 投入固体方块,供铁轨放置其上。
每个存储仅接受它能使用的物品。破坏车厢会掉落它当前持有的所有物品。
需要调整设置?编辑 plugins/AutoCartSystem/config.yml,然后运行 /acs reload ——无需重启服务器。
合成配方
- 每个 ACS 车厢都可以在合成台中制作,并出现在配方书里(首次加入服务器时自动发现)。操作员也可以使用
/acs give。
- 配方是无形状的——将列出的物品放在网格的任何位置即可。
- 合成的车厢具有完整的标签,其行为与通过
/acs give 获得的完全相同。
- 可以通过
recipes.enabled: false(参见 配置)在全服务器范围内禁用配方;此后车厢仅可通过 /acs give 获得。
- 注意: 由于 ACS 车厢是原版矿车物品的特殊变体,它们无法添加到创造模式的物品搜索列表中(该菜单由客户端固定)。在创造模式中,通过配方书或
/acs give 获取它们。
- 每个配方都包含一个铁链——这是“耦合器”硬件,允许车厢链接成列车。
| 车厢 |
材料 |
| 矿车 |
矿车 + 铁链 |
| 驾驶员车厢 |
矿车 + 杠杆 + 铁链 |
| 箱子矿车 |
箱子矿车 + 铁链 |
| 漏斗矿车 |
漏斗矿车 + 铁链 |
| 熔炉矿车 |
熔炉矿车 + 铁链 |
| TNT 矿车 |
TNT 矿车 + 铁链 |
| 自动铺轨器 |
矿车 + 发射器 + 铁轨 + 铁链 |
| 自动架桥器 |
矿车 + 发射器 + 圆石 + 铁链 |
| 钻头车厢 |
矿车 + 钻石镐 + 活塞 + 铁链 |
| 引擎车厢 |
熔炉矿车 + 红石块 + 铁链 |
| 长漏斗 |
漏斗 + 铁链 |
- 长漏斗是唯一一个产出方块而非车厢的配方——它的铁链是一种主题升级,而不是列车耦合器(长漏斗不进行耦合)。参见下方的 长漏斗。
车厢与列车详解
车厢耦合
- 车厢仅在放置时连接:将 ACS 车厢放置在紧邻现有 ACS 车厢的铁轨上,两者便会链接在一起。仅仅是相互碰撞的车厢永远不会连接。
- 手持 ACS 车厢并看向铁轨时,任何你会与之连接的车厢都会发光,以便你在放置前查看连接情况;一旦移开视线,光芒随即消失。
- 连接后的车厢会形成一列“列车”,其他 ACS 系统会将其识别为列车,且列车保持刚性编队(撞击不会使车厢脱钩)。
- 所有 ACS 车厢均可连接——不存在单独的“可连接”和“不可连接”变体。一个车厢最多连接两个相邻车厢(两端各一个),因此列车始终保持单线排列。
- 在两列独立的列车之间放置车厢会将它们合并为一列(受长度限制约束)。
- 破坏车厢会使其脱钩,并将列车在缺口处干净地分开。
- 列车限长为 20 节车厢;一旦列车达到该长度,不再有新车厢与其连接。
自动铺轨层
- 若前方有合法方块可供铺设铁轨,则在前部铺设铁轨的车厢类型
- 车厢仅向前方 1 个方块的距离内探测以铺设铁轨
- 该车厢充当仅能存储铁轨的储物箱,并消耗其存储中的铁轨来铺设轨道
- 如果列车中有多个铺轨层,它们仅作为额外的铁轨存储空间
自动架桥层
- 若列车所处高度存在空白区域,则在前部铺设桥梁方块的车厢类型
- 车厢仅向前方 1 个方块的距离内探测以铺设铁轨(注:原文此处重复了铺轨层的描述,根据上下文应指架桥探测范围)
- 该车厢充当仅能存储方块的储物箱,并消耗其存储中的方块来搭建桥梁
- 只能存储那些可以承载铁轨的方块
- 它会按顺序从存储中的每个物品组中取出 1 个方块,因此可以通过交替方块类型来制作图案
- 如果列车中有多个架桥层,它们仅作为额外的存储空间
钻头车厢
- 按照可配置的模式(2x1、2x2 右、2x2 左、3x2、3x3)直接在前方进行挖掘的车厢类型
- 该车厢充当仅能存储镐子的储物箱,并在挖掘过程中消耗镐子
- 钻头车厢只能连接到列车的前部(单独存在的引擎接受任一侧连接的钻头,此时该侧变为前部),每列列车只能有 1 个钻头
- 速度取决于所使用的镐子
- 在钻头车厢中使用时,镐子的消耗速度是正常速度的 2 倍
引擎车厢
- 作用类似燃煤炉车厢但速度更快,并由连接的控制驾驶车厢(见 Driver cart)控制方向
- 一节引擎车厢可以将任意大小的列车拉上任何山坡
- 引擎车厢充当仅能存储燃料的储物箱
- 引擎车厢的最高速度与原版矿车的最高速度相同
- 速度取决于所使用的燃料,类似于熔炉对燃料的效率,但一块煤炭提供的最大速度与一桶岩浆水相同
- 燃料燃烧速率仅为熔炉的一半(持续时间加倍)
- 引擎车厢仅在移动时使用燃料
- 当列车上没有控制驾驶车厢时,引擎处于自动驱动模式:只要它有燃料,它就会自行向前驱动列车(这是列车信号控制的模式)
- 引擎车厢会使所在的区块保持加载状态,从而确保区块始终处理游戏刻
- 引擎车厢始终是列车的前部(第 1 号车厢)——除非有钻头车厢,在这种情况下,钻头是 #1,引擎是 #2
- 单独的引擎有一个默认航向,直到你将其与某物连接。你在哪一侧放置车厢决定了方向(而不是你面对的方向):在一侧连接钻头会使该侧成为前部(引擎朝向钻头行驶);在任何一侧连接任何其他车厢会使该侧成为后部(引擎朝另一方向行驶)
- 一旦列车包含除引擎以外的其他部分,钻头只能连接在前部,且引擎或钻头前方不得连接任何车厢——违反此规则的放置操作是不允许的,也不会高亮显示
控制驾驶车厢 (Driver cart)
- 一种专用的可骑乘车厢,允许骑乘它的玩家控制列车——普通的可骑乘矿车从不授予控制权
- 由普通矿车、拉杆和铁链合成(或使用
/acs give driver)
- 每当控制驾驶车厢连接到列车时,引擎停止自动驱动,即使装有燃料也是如此:列车仅在骑乘者的控制下移动。因此,空的控制驾驶车厢会使列车静止不动
- 骑乘控制驾驶车厢并按如下操作:
- 按前进或后退以移动列车(前进朝向列车前端,后退使其倒车)
- 按左或右以转向/转弯列车:这会使铺轨层、架桥层和钻头在列车前端左侧或右侧行动,而不是正前方——就像轨道在此弯曲一样——从而使新铺设/挖掘的路径弯曲,列车随之绕行
- 控制驾驶车厢可以连接在引擎后面的任何位置(像任何其他非钻头车厢一样连接到列车尾部)
- 列车信号仅管辖自动驱动(引擎,无控制驾驶车厢)的列车——带有控制驾驶车厢的列车会忽略信号,因为骑手处于控制状态
长漏斗 (Long Hopper)
- 作用与普通漏斗完全相同,但它会将物品推入距离漏斗末端最多 20 个方块远的箱子中,而不仅仅是紧邻漏斗末端的箱子
- 通过合成(漏斗 + 铁链)或使用
/acs give long_hopper 获得——它是一个漏斗方块物品,而非车厢
- 放置它(拥有
acs.place 权限)会创建长漏斗;破坏它会返回长漏斗物品,以免丢失升级
- 禁用
longHopper.enabled 会导致放置失败并显示消息;现有的长漏斗将停止其远距离推送功能
告示牌命令
- 所有 ACS 告示牌命令必须以
[ACS:<TYPE>] 开头,位于告示牌的第一行,其后跟随具体的命令参数
- 所有告示牌的文本都会被转换为其他内容,以隐藏命令
漏斗告示牌
- 你可以通过用 ACS 告示牌标记箱子,使所有漏斗(包括原版漏斗)仅将特定物品放入该箱子
- 每行列出一种物品 ID — 最多 3 种 ID(第 2-4 行,因为第一行是
[ACS:HOPPER] 标签)。然后该箱子接受列出的任何物品
- ID 之间的空行会被忽略;重复的 ID 会被合并;至少需要一种有效的 ID
- 双人箱被视为一个箱子:在任一半侧放置告示牌均适用于整个箱子,如果两侧都进行了标记,则它们的过滤器会合并(因此双人箱可以接受多达 6 种物品类型)
- 格式:
[ACS:HOPPER]
<ITEM_ID>
<ITEM_ID>
<ITEM_ID>
[ACS:HOPPER]
diamond
- 示例 — 一个箱子中最多三种物品(接受煤炭、木炭或煤块):
[ACS:HOPPER]
coal
charcoal
coal_block
- 如果生效,告示牌将显示与 ITEM_ID 关联的方块名称
垃圾桶告示牌
- 使用 ACS 垃圾桶告示牌标记的箱子将删除插入其中的所有物品
- 格式:
[ACS:TRASH]
火车信号告示牌
[ACS:SIGNAL]
<CONDITION 1>
<OPERATOR> <CONDITION 2>
<OPERATOR> <CONDITION 3>
- 示例 1:当以下条件中任意一个为真时,信号将变绿:所有储物箱为空,或已过 30 秒,或此点后方 10 个轨道上没有火车(只需其中一个为真即可)
[ACS:SIGNAL]
ALL_EMPTY
OR WAIT 30
OR NO_TRAIN 10
- 示例 2:当以下两个条件同时为真时,信号将变绿:所有储物箱已满,且已过 80 秒(两个条件都必须为真)
[ACS:SIGNAL]
ALL_FULL
AND WAIT 80
示例
装卸车厢系统一直可行,但现在你可以让多列火车可靠运行,并使用信号防止它们相互碰撞。下面的示例将上述车厢、[ACS:SIGNAL] 告示牌和长距离漏斗结合成完整、可用的设置。
信号仅影响引擎驱动的火车(不是玩家驾驶的火车),因此下面每个循环都依赖每列火车至少有一节引擎车厢。请参阅 火车信号告示牌 以获取完整的条件/运算符参考。
1. 带双列车运输循环的自动钻探露天矿
主要设置:一个自行挖掘的露天矿,它会铺设自己的轨道,加上两列运输火车将矿石运回基地——全部不会发生碰撞。
挖掘火车
在前方连接一个钻头车厢,在其后方连接一个引擎车厢,以及一个或多个装载了铁轨的轨道铺设层车厢。(如果你预计要跨越间隙,请添加装有圆石的桥梁铺设层。)由于存在钻头,钻头是第 1 号车厢,引擎是第 2 号车厢——它将整列火车拉向岩石前方前进。
- 在钻头车厢中装满镐,在轨道铺设层中装满铁轨。
- 当它向前行驶时,它会挖掘配置的图案(例如
THREE_BY_THREE)并在身后铺设轨道,自动延伸矿道。
- 驾驶员可以点击左/右来摆动钻头/轨道铺设层到侧面并控制条纹路径。
将轨道加倍成环
在刚挖掘的主干线旁铺设第二条平行轨道,并连接两端使其形成环路:一列火车在一侧轨道驶向矿面,另一列在另一侧轨道返回基地。在环路上运行两列运输火车,每列由引擎车厢 + 储物箱车厢组成,保持间距,使得一列在矿场装载时,另一列在基地卸载。
防止碰撞
在轨道旁放置信号告示牌(在地面或旁边的方块上),面向火车接近的方向。
在矿面——在前面的火车停留 5 分钟以便手动装载:
[ACS:SIGNAL]
WAIT 300
在它停在那里时,将你露天开采的所有东西——钻石、煤炭、绿宝石、矿石——倒入其储物箱车厢。当 5 分钟过去后,信号变绿,它便启程回家。
紧随其后——防止第二列火车追尾第一列:
[ACS:SIGNAL]
NO_TRAIN 10
当前方 10 格轨道内仍有第一列火车时,此信号保持红色;待该列车驶离后变为绿色——因此,后方列车仅在领头列车离开装载区后才会前进。
在基础卸货点 —— 将每列火车扣留直至其箱子为空:
[ACS:SIGNAL]
ALL_EMPTY
列车停靠在卸载点上,直到所有普通箱子矿车都被清空(通过下方的漏斗清空——见下一个示例),之后才会倒车返回矿井。结合使用这三个标志牌,你可以实现一个连续的往返循环,确保载重列车与空车永远不会相遇。
2. 使用长漏斗进行货物分拣
示例 1 中的卸货箱里会堆积各种杂乱的材料。使用长漏斗将其扇形展开到分拣墙中。
- 将卸货箱接入长漏斗,它可以向最多 20 格远(可通过
longHopper.range 配置)的任何箱子推送物品,而不仅仅是相邻的方块。
- 为每个目标箱子贴上 [ACS:HOPPER] 过滤标志牌,这样只有匹配的物品才会落入其中:
[ACS:HOPPER]
diamond
[ACS:HOPPER]
coal
[ACS:HOPPER]
emerald
- 将长漏斗指向这排贴有标签的箱子,每种材料都会自动路由到对应的箱子中——一个钻石箱、一个煤炭箱、一个绿宝石箱,以此类推。长漏斗按顺序(最近优先)向箱子提供物品,并将其放入第一个接受且有空间的箱子中,跳过已满的箱子。
- 一个过滤标志牌可以列出最多 3 个物品 ID(每行一个),因此单个箱子可以收集一组相关的材料:
[ACS:HOPPER]
coal
charcoal
coal_block
- 未标记的箱子充当全能接收器(接受所有物品),因此请将它——或标记为 [ACS:TRASH] 的箱子(删除插入其中的所有物品)——放置在队列的末尾,以清理前面过滤箱未认领的剩余物品。
3. 从已分拣的煤炭中为引擎自动加油
引擎燃烧燃料,而你在示例 2 中分拣出的煤炭可以为它们免费加油。
- 在轨道经过上方有一个漏斗向下 feeding 的箱子的环路处建造一个加油停靠点——引擎矿车仅作为燃料存储单元,因此轨道上方的漏斗可以为它们加满油。
- 从长漏斗分拣器产生的煤炭箱中填充该箱子,从而使露天开采的煤炭直接循环用于驱动火车。
- 在停靠点短暂扣留列车以加载燃料。定时信号效果良好:
[ACS:SIGNAL]
WAIT 5
- 对于更智能的版本,可以基于货运周期进行门控——例如,仅在空车段加油,通过与卸载停靠点配对来实现。记住引擎仅在移动时消耗燃料,且燃烧速率仅为熔炉的一半(
engine.fuelBurnRateMultiplier: 0.5),因此每圈短暂的加油即可让它们无限期运行。
4. 带有检查站停靠点的乘客车站
相同的信号系统可以构建一条等待乘客并在每个车站暂停的客运线路。
- 由引擎矿车 + 可乘坐/乘客矿车组成列车。车站只是平台旁边的一段轨道。
- 在每个站台,短暂扣留列车以便乘客上下车:
[ACS:SIGNAL]
WAIT 10
- 若要仅在列车满载乘客后发车,请将出发条件设置为
ALL_FULL_P——它在每个可乘坐矿车都有玩家上车之前保持红色,然后变为绿色。将其与 WAIT 配合使用,以便部分满载的列车最终仍能出发,而不是让乘客滞留:
[ACS:SIGNAL]
ALL_FULL_P
OR WAIT 60
- 铺设一条包含多个车站的环路,并在其上运行多列引擎列车,通过
NO_TRAIN 信号(如示例 1 所示)保持间距,使它们不会扎堆或相撞。
- 结果:每列列车进站,在每个检查站等待几秒让乘客上下车,然后继续围绕环路运行——这是一条全自动的地铁线路。
提示:由于驾驶矿车会覆盖信号(并阻止引擎自动驾驶),将驾驶矿车耦合到列车上并骑乘它可以让您接管手动控制并驶离自动化环路。如果您希望列车独立在环路上运行,请不要在任何这样的列车上放置驾驶矿车。
混合使用
这些功能相互叠加:露天采矿环路(1)喂养长漏斗分拣器(2),分拣出的煤炭为引擎加油(3),相同的信号模式驱动客运网络(4)。在 Configuration 中调整所有限制——列车长度、漏斗范围、信号距离、等待时间——并使用 /acs reload 实时应用更改。
命令
AutoCartSystem 提供了一个基础命令。
/acs <subcommand> [args...]
- 别名:
/autocart, /autocartsystem
- 基础权限:
acs.command(默认:所有玩家)
不带参数运行 /acs(或 /acs help)将显示游戏内的命令列表。有关权限节点,请参阅 Permissions。
/acs reload
重新加载插件:从磁盘重新读取 config.yml 并在运行时重新应用所有设置。无需重启服务器即可使配置更改生效。
|
|
| 语法 |
/acs reload |
| 权限 |
acs.command.reload(默认:op) |
| 示例 |
/acs reload |
/acs give
给予玩家一个 ACS 物品(矿车或长漏斗方块)。
|
|
| 语法 |
/acs give <type> [amount] [player] |
| 权限 |
acs.command.give(默认:op) |
参数
| 参数 |
必需 |
描述 |
type |
是 |
物品类型(见下表)。 |
amount |
否 |
给予的物品数量(最小值为 1)。默认为 1。 |
player |
否 |
目标玩家。默认为发送者;从控制台运行时必填。 |
可选参数是位置性的,但每个参数都通过其形状(整数,然后是名称)进行检测,因此必须按照上述顺序出现。所有 ACS 矿车都可以耦合——不再有需要选择的耦合/非耦合变体。
类型(不区分大小写)
| 类型 |
给予的物品 |
rideable |
矿车 |
driver |
驾驶员矿车 |
chest |
储物矿车 |
hopper |
漏斗矿车 |
furnace |
熔炉矿车 |
tnt |
TNT 矿车 |
track_layer |
自动铺轨层 |
bridge_layer |
自动架桥层 |
drill |
钻头矿车 |
engine |
引擎矿车 |
long_hopper |
长距离漏斗(漏斗方块物品,非矿车) |
示例
/acs give engine # 给你自己 1 个引擎矿车
/acs give drill # 给你自己 1 个钻头矿车
/acs give track_layer 16 # 16 个铺轨层
/acs give chest 4 Steve # 给 Steve 4 个储物矿车
/acs give long_hopper 2 # 给你自己 2 个长距离漏斗
/acs info
显示你当前骑乘的矿车的 AutoCartSystem 详细信息;如果你没有骑乘任何矿车,则显示你正对着的矿车信息(6 格范围内)。仅限玩家使用。
报告的详细信息包括:矿车类型、与其耦合连接的矿车数量、钻头模式(仅限钻头矿车),以及当矿车属于被追踪的列车时:列车大小、在列车中的位置、朝向、列车是否拥有引擎或钻头、普通储物箱数量、功能性矿车数量,以及当前的驾驶员。
|
|
| 语法 |
/acs info |
| 权限 |
acs.command.info(默认:所有玩家) |
| 示例 |
/acs info |
/acs help
列出上述子命令及其用法。仅需基础 acs.command 权限。
|
|
| 语法 |
/acs help |
| 权限 |
acs.command |
| 示例 |
/acs help |
配置
所有数值和大部分功能均可在配置文件(plugins/AutoCartSystem/config.yml)中启用或禁用。
大多数功能都有一个 enabled 总开关。数值限制可调。编辑文件后,通过 /acs reload 运行时应用更改——无需重启服务器。
耦合矿车 (coupling)
控制放置时的耦合(及其放置高亮),将矿车连接为可识别的“列车”。
| 键 |
用途 |
类型 |
默认值 |
coupling.enabled |
耦合功能的总开关。关闭时,放置的矿车永远不会耦合,放置高亮将被隐藏,且已耦合的列车将失去碰撞免疫特性。 |
boolean |
true |
coupling.maxTrainLength |
单个耦合列车中允许的最大矿车数量。达到此长度后,不再有新矿车进行耦合。 |
integer |
20 |
自动铺轨层 (trackLayer)
铺轨层矿车会在列车前端铺设铁轨。
| 键 |
用途 |
类型 |
默认值 |
trackLayer.enabled |
铺轨层矿车功能的总开关。 |
boolean |
true |
trackLayer.lookAhead |
铺轨层在列车前端前方多少格内查找以铺设铁轨。 |
integer |
1 |
自动架桥层 (bridgeLayer)
当列车跨越间隙时,架桥层矿车会在前方铺设桥梁方块。
| 键 |
用途 |
类型 |
默认值 |
bridgeLayer.enabled |
架桥层矿车功能的总开关。 |
boolean |
true |
bridgeLayer.lookAhead |
架桥器在列车前端前方多少格内查找以放置方块。 |
integer |
1 |
钻头矿车 (drill)
钻头矿车会以可配置的图案直接挖掘列车前方的方块。
| 键 |
用途 |
类型 |
默认值 |
drill.enabled |
钻头矿车功能的总开关。 |
boolean |
true |
drill.defaultPattern |
新创建的钻头矿车的默认挖掘模式。可选值:ONE_BY_TWO, TWO_BY_ONE, TWO_BY_TWO_RIGHT, TWO_BY_TWO_LEFT, THREE_BY_TWO, THREE_BY_THREE。 |
string (enum) |
ONE_BY_TWO |
drill.pickaxeConsumptionMultiplier |
镐子的消耗速度是正常耐久度损耗的多少倍。 |
decimal |
2.0 |
引擎矿车 (engine)
引擎矿车为列车提供动力,并可由玩家驾驶。
| 键 |
用途 |
类型 |
默认值 |
engine.enabled |
引擎矿车功能的总开关。 |
boolean |
true |
engine.fuelBurnRateMultiplier |
燃料燃烧速率相对于熔炉标准速率的比例(0.5 => 燃料持续时间加倍)。 |
decimal |
0.5 |
engine.maxSpeed |
最大引擎速度(单位:格/刻)。原版矿车的最大速度为 0.4。 |
decimal |
0.4 |
长距离漏斗 (longHopper)
长距离漏斗可将物品推入远超其紧邻方块的远处储物箱中。
| 键 |
用途 |
类型 |
默认值 |
longHopper.enabled |
长距离漏斗功能的总开关。 |
boolean |
true |
longHopper.range |
从漏斗输出端到目标储物箱的最大距离(单位:格)。 |
integer |
20 |
longHopper.reach |
长距离漏斗在搜索目标时,每tick能延伸多远。 |
integer |
20 |
合成配方 (recipes)
控制生成 ACS 矿车物品的合成配方(参见 合成配方)。
| 键 |
用途 |
类型 |
默认值 |
recipes.enabled |
ACS 矿车合成配方的总开关。当设为 false 时,矿车仅可通过 /acs give 获得。 |
boolean |
true |
告示牌 (signs)
控制所有 ACS 告示牌命令处理。
| 键 |
用途 |
类型 |
默认值 |
signs.enabled |
所有 ACS 告示牌命令处理(HOPPER, TRASH, SIGNAL)的总开关。 |
boolean |
true |
信号 (signals)
控制引擎列车信号告示牌([ACS:SIGNAL])。
| 键 |
用途 |
类型 |
默认值 |
signals.enabled |
引擎列车信号标志的主开关。 |
boolean |
true |
signals.noTrainMaxTracks |
NO_TRAIN 条件最多可向前扫描的轨道数量。 |
integer |
20 |
signals.waitMaxSeconds |
WAIT 条件允许指定的最大秒数。 |
integer |
600 |
signals.scanAhead |
每个刻(tick)在列车前端前方扫描多少个方块以查找信号标志。 |
integer |
8 |
signals.stopDistance |
列车接近红色信号时,自动驾驶列车减速至停止的距离(以方块为单位)。 |
decimal |
6.0 |
调试 (debug)
| 键 |
用途 |
类型 |
默认值 |
debug |
启用详细的控制台日志记录(例如列车前端/方向变化),用于故障排除。 |
boolean |
false |
权限
AutoCartSystem 在 plugin.yml 中声明了以下权限节点。default 列显示了开箱即用时哪些角色拥有该节点:
true — 默认授予所有玩家。
op — 默认仅授予服务器管理员。
你可以使用权限插件按组或按玩家覆盖任何节点的权限。
放置和使用
这些权限控制谁可以放置 ACS 物品以创建特殊车厢(以及长漏斗方块)。
| 节点 |
授予权限 |
默认值 |
acs.place |
放置 ACS 物品:用于创建特殊车厢的车厢物品,以及用于创建长漏斗的物品。 |
true |
标志牌
这些权限控制玩家可以创建哪些类型的 ACS 标志牌。
| 节点 |
授予权限 |
默认值 |
acs.sign.hopper |
创建 [ACS:HOPPER] 物品过滤标志牌。 |
true |
acs.sign.trash |
创建 [ACS:TRASH] 标志牌。 |
true |
acs.sign.signal |
创建 [ACS:SIGNAL] 列车信号标志牌。 |
true |
命令和管理
这些权限控制对 /acs 命令及其子命令的访问。
| 节点 |
授予权限 |
默认值 |
acs.command |
基础访问 /acs 命令。 |
true |
acs.command.info |
使用 /acs info。 |
true |
acs.command.reload |
使用 /acs reload 重新加载配置。 |
op |
acs.command.give |
使用 /acs give 生成 ACS 车厢物品。 |
op |
AutoCartSystem
Build rail networks that build themselves. AutoCartSystem turns minecarts into a self-laying, self-mining, self-bridging, driveable train system — so reaching distant places by rail is finally faster than walking there.
Lay track, bore tunnels, span chasms, haul resources, and signal stations, all from carts on the rails. Then couple them into trains and drive them with a real engine.
Requires Minecraft 26.x or newer (Paper)
Why?
The idea of mining with a minecart to send resources back to your base is enticing, but ultimately impractical. The effort required to build the rail network is many times harder than just mining out a mineshaft on foot and walking back.
The preparation needed to bore holes, make bridges, lay the track, and add powered rails is high. Then you start to strip mine near your cart and before you know it you're 1000s of blocks away from your cart in far less time than it took to just get the cart there. This plugin seeks to address those problems and more.
Features
- Coupling carts & trains — couple carts together into recognised trains (up to 20 long). Coupling variants exist for every vanilla and ACS cart type.
- Auto Track Layer — lays rail at the front of the train from its own rail storage, so the track grows as you go.
- Auto Bridge Layer — fills gaps under the rail with blocks from its storage; alternate block types for patterned bridges.
- Drill Cart — mines ahead of the train in a configurable pattern (1x2, 2x1, 2x2 left/right, 3x2, 3x3), consuming pickaxes from its storage.
- Engine Cart — a faster, smarter furnace cart that pulls trains of any size up any hill and can be driven by a player riding a coupled driver cart. Keeps its chunk loaded so the train keeps moving.
- Driver Cart — a dedicated rideable cart that hands the rider control of the train and lets you steer the track/drill left and right.
- Long Hopper — pushes items into any chest up to 20 blocks from the hopper's output end, not just the adjacent block.
- Smart Signs —
[ACS:HOPPER] item filters, [ACS:TRASH] voiding chests, and [ACS:SIGNAL] train signals that slow and stop auto-driven trains until conditions (chest empty/full, timers, clear-track) are met.
Quick start
-
Drop the AutoCartSystem .jar into your server's plugins/ folder.
-
Start (or restart) your Paper 26.x+ server. A default config.yml is generated on first run.
-
Give yourself some carts and place them on rails:
/acs give engine
/acs give track_layer 64
/acs give drill true
-
Couple them up, fuel the engine, hop in the cart behind it, and drive forward.
ACS carts are not creative-menu items — there is nothing new to find in the creative inventory. Get them by crafting (see Crafting recipes) or with /acs give <type> (op by default).
Filling & configuring carts
The functional carts (engine, drill, track layer, bridge layer) each carry their own storage. Sneak + right-click a placed cart to open its storage GUI:
- Engine — drop in fuel (coal, a block of coal, lava buckets, etc.). The engine is a furnace minecart you can't sit in; it's driven from a coupled driver cart. (Right-clicking without sneaking does nothing — it won't accept hand-fed fuel like a vanilla furnace cart.)
- Drill — drop in pickaxes; click the compass button in the GUI to cycle the mining pattern (1x2 → 2x2 right → 2x2 left → 3x2 → 3x3).
- Track layer — drop in rails. Bridge layer — drop in solid blocks rails can sit on.
Each storage only accepts items it can use. Breaking a cart drops whatever it was holding.
Need to tweak a setting? Edit plugins/AutoCartSystem/config.yml, then run /acs reload — no restart required.
Crafting recipes
- Every ACS cart can be crafted in a crafting table and appears in the recipe book (auto-discovered the first time you join). Operators can also use
/acs give.
- Recipes are shapeless — drop the listed items anywhere in the grid.
- Crafted carts are fully tagged and behave identically to ones from
/acs give.
- Recipes can be disabled server-wide with
recipes.enabled: false (see Configuration); carts then remain available via /acs give only.
- Note: because ACS carts are special variants of vanilla minecart items, they cannot be added to the creative-mode item search list (that menu is fixed by the client). In creative, obtain them via the recipe book or
/acs give.
- Every recipe includes one Iron Chain — the "coupler" hardware that lets the cart link into a train.
| Cart |
Ingredients |
| Minecart |
Minecart + Iron Chain |
| Driver Cart |
Minecart + Lever + Iron Chain |
| Chest Minecart |
Chest Minecart + Iron Chain |
| Hopper Minecart |
Hopper Minecart + Iron Chain |
| Furnace Minecart |
Furnace Minecart + Iron Chain |
| TNT Minecart |
TNT Minecart + Iron Chain |
| Auto Track Layer |
Minecart + Dispenser + Rail + Iron Chain |
| Auto Bridge Layer |
Minecart + Dispenser + Cobblestone + Iron Chain |
| Drill Cart |
Minecart + Diamond Pickaxe + Piston + Iron Chain |
| Engine Cart |
Furnace Minecart + Block of Redstone + Iron Chain |
| Long Hopper |
Hopper + Iron Chain |
- The Long Hopper is the one recipe that produces a block, not a cart — its Iron Chain is a thematic upgrade rather than a train coupler (a long hopper does not couple). See Long Hopper below.
Carts & trains in detail
Coupling carts
- Carts couple only at placement time: place an ACS cart on a rail next to an existing ACS cart and the two link together. Carts that merely run into each other never connect.
- While holding an ACS cart and looking at a rail, any existing cart you would couple to glows, so you can see the connection before you place; the glow clears as soon as you look away.
- Coupled carts create a "train" which is recognized by other ACS systems, and the train is held rigidly in formation (bumping it will not knock carts loose).
- Every ACS cart can couple — there are no separate "coupling" and "non-coupling" variants. A cart links to at most two neighbours (one toward each end), so trains stay in a single line.
- Placing a cart between two separate trains joins them into one (subject to the length limit).
- Breaking a cart decouples it and splits the train cleanly around the gap.
- Trains are limited to 20 carts; once a train reaches that length, no new carts will couple to it.
Auto track layer
- Cart type that lays a track at the front of the train if there is a legal block to place tracks on
- Cart will only look up to 1 block away from the front of the train to lay tracks
- Cart acts as a storage chest that can only hold tracks, and consumes the tracks from its storage to lay track
- If there is more than one track layer in a train they just act as extra storage for tracks
Auto bridge layer
- Cart type that lays bridging blocks at the front of the train if there is a blank spot at the height the train is sitting on
- Cart will only look up to 1 block away from the front of the train to lay tracks
- Cart acts as a storage chest that can only hold blocks and consumes the blocks from its storage to lay bridges
- Can only store blocks that tracks can have tracks on them
- It will take 1 block from each stack in the storage in sequence so patterns can be made by alternating block types
- If there is more than one bridge layer in a train they just act as extra storage
Drill cart
- Cart type that drills directly in front of it in a configurable pattern (2x1, 2x2 right, 2x2 left, 3x2, 3x3)
- Cart acts as a storage chest that can only hold pickaxes which are consumed while mining
- Drill carts can only connect to the front of a train (a lone engine accepts a drill on either side, which then becomes the front), there can only be 1 on a train
- Speed is dependent on the pickaxe being used
- Pickaxes are consumed 2x faster than normal while being used in a drill cart
Engine cart
- Acts like a coal furnace cart but is faster, and is steered by a coupled driver cart (see Driver cart)
- One engine cart can pull a train of any size up any hill
- Engine carts act as a storage chest that can only hold fuel
- Engine carts max speed is the same as a vanilla carts max speed
- Speed is dependent on the fuel being used similar to furnace efficiency for fuel except that a block of coal will provide max speed same as a lava bucket
- Fuel burns at half the rate it does for furnaces (lasts twice as long)
- Engine carts only use fuel while moving
- With no driver cart on the train, the engine is auto-driven: as long as it has fuel it drives the train forward on its own (this is the mode train signals control)
- Engine carts will cause the chunk they are in to stay loaded so the chunk always processes ticks
- The engine cart is always the front of the train (cart #1) — unless there is a drill cart, in which case the drill is #1 and the engine is #2
- A lone engine has a default heading until you couple something to it. The side you place a cart on decides the direction (not the way you are facing): coupling a drill to one side makes that side the front (the engine drives toward the drill); coupling any other cart to one side makes that side the back (the engine drives the other way)
- Once a train has more than just the engine, a drill only couples at the front and nothing couples ahead of the engine or the drill — placements that would break this are not allowed and do not highlight
Driver cart
- A dedicated rideable cart that lets the player riding it control the train — regular rideable minecarts never grant control
- Crafted from a regular minecart, a lever and an iron chain (or
/acs give driver)
- Whenever a driver cart is coupled to a train, the engine stops auto-driving even with fuel loaded: the train moves only under the rider's control. An empty driver cart therefore holds the train still
- Ride the driver cart and:
- Press forward or backward to move the train (forward heads toward the front of the train, backward reverses it)
- Press left or right to steer/turn the train: this makes the track layer, bridge layer and drill act to the left or right of the front of the train instead of straight ahead — exactly as if the track bent that way — so the freshly laid/drilled path curves and the train follows it around
- The driver cart can be coupled anywhere behind the engine (it couples onto the back of the train like any non-drill cart)
- Train signals only govern auto-driven (engine, no driver cart) trains — a train with a driver cart ignores signals, since the rider is in control
Long Hopper
- Acts exactly like a regular hopper except that it will push items into chests up to 20 blocks away from the end of the hopper instead of only the chest right next to the end of the hopper
- Obtain one by crafting (Hopper + Iron Chain) or with
/acs give long_hopper — it is a hopper block item, not a cart
- Placing it (with the
acs.place permission) creates a long hopper; breaking it returns the long hopper item so the upgrade is not lost
- Disabling
longHopper.enabled makes placement fail with a message; existing long hoppers stop their long-range push
Sign commands
- All ACS sign commands must start with
[ACS:<TYPE>] on the first line of the sign then followed by the specific command parameters
- All signs will have the text transformed to something else to hide the command afterwards
Hopper signs
- You can cause all hoppers (including vanilla hoppers) to only put certain items in a chest by labelling the chest with an ACS sign
- List one item id per line — up to 3 ids (lines 2-4, since the first line is the
[ACS:HOPPER] tag). The chest then accepts any of the listed items
- Blank lines between ids are ignored; duplicate ids are collapsed; at least one valid id is required
- Double chests count as one chest: a sign on either half applies to the whole chest, and if both halves are labelled their filters combine (so a double chest can accept up to 6 item types)
- Format:
[ACS:HOPPER]
<ITEM_ID>
<ITEM_ID>
<ITEM_ID>
[ACS:HOPPER]
diamond
- Example — up to three items in one chest (accepts coal, charcoal, or a coal block):
[ACS:HOPPER]
coal
charcoal
coal_block
- The sign will just display the names of the blocks associated with the ITEM_IDs if it works
Trash signs
- A chest labelled with an ACS Trash sign will delete all items inserted into it
- Format:
[ACS:TRASH]
Train signal signs
[ACS:SIGNAL]
<CONDITION 1>
<OPERATOR> <CONDITION 2>
<OPERATOR> <CONDITION 3>
- Example 1: This signal will be green when any of the conditions are true, either all the chests are empty, or 30s has passed or there are no trains 10 tracks beyond this point (only one of these needs to be true)
[ACS:SIGNAL]
ALL_EMPTY
OR WAIT 30
OR NO_TRAIN 10
- Example 2: This signal will be green when both of the conditions are true, all the chests are full, and 80s has passed (both conditions must be true)
[ACS:SIGNAL]
ALL_FULL
AND WAIT 80
Examples
Loading and unloading cart systems have always been possible, but now you can keep multiple trains running reliably and use signals to prevent them from crashing into each other. The examples below combine the carts above, the [ACS:SIGNAL] signs, and the long hopper into complete, working setups.
Signals only affect engine-driven trains (not trains a player is driving), so every loop below relies on at least one engine cart per train. See Train signal signs for the full condition/operator reference.
1. Auto-drilling strip mine with a two-train haul loop
The headline setup: a self-digging strip mine that lays its own track, plus a pair of hauler trains that shuttle the ore back to base — all without crashing.
The digging train
Couple a drill cart to the front, an engine cart behind it, and one or more track layer carts loaded with rail. (Add a bridge layer with cobblestone if you expect to cross gaps.) Because a drill is present, the drill is cart #1 and the engine is #2 — it pulls the whole train forward into the rock.
- Fill the drill cart with pickaxes and the track layer with rails.
- As it drives forward it mines the configured pattern (e.g.
THREE_BY_THREE) and lays track behind itself, extending the mine automatically.
- A driver can tap left/right to swing the drill/track layer to the side and steer the strip.
Doubling the track into a loop
Lay a second, parallel track alongside the freshly-dug main line and join the ends so it forms a loop: trains run out to the mine face on one rail and back to base on the other. Run two hauler trains on the loop, each an engine cart + chest carts, spaced apart so one is loading at the mine while the other is unloading at base.
Keeping them from colliding
Place signal signs beside the track (on the ground or a block beside it), facing the direction trains approach from.
At the mine face — hold the front train for 5 minutes so you can load it by hand:
[ACS:SIGNAL]
WAIT 300
While it sits there, dump everything you strip-mined — diamonds, coal, emeralds, ores — into its chest carts. When the 5 minutes elapse the signal goes green and it heads home.
Just behind it — keep the second train from rear-ending the first:
[ACS:SIGNAL]
NO_TRAIN 10
This signal stays red while the first train is still within 10 tracks ahead, then goes green once that train has pulled away — so the trailing train only advances into the loading zone after the leader leaves.
At the base drop-off — hold each train until its chests are empty:
[ACS:SIGNAL]
ALL_EMPTY
The train parks over the unload point and won't leave until every regular chest cart has been drained (by hoppers underneath — see the next example), then rolls back out to the mine. Combined, the three signs give you a continuous out-and-back loop where loaded and empty trains never meet.
2. Sorting the haul with long hoppers
The drop-off chest from Example 1 fills with a jumble of materials. Use the long hopper to fan it out into a sorting wall.
- Feed the unload chest into a long hopper, which can push into any chest up to 20 blocks away (configurable via
longHopper.range) instead of only the adjacent block.
- Label each destination chest with a [ACS:HOPPER] filter sign so only the matching item lands there:
[ACS:HOPPER]
diamond
[ACS:HOPPER]
coal
[ACS:HOPPER]
emerald
- Point the long hopper at the bank of labelled chests and each material routes itself into its own chest — one diamond chest, one coal chest, one emerald chest, and so on. The long hopper offers each item to the chests in line order (nearest first) and drops it into the first one that accepts it and has room, skipping full chests.
- A filter sign can list up to 3 item ids (one per line), so a single chest can collect a group of related materials:
[ACS:HOPPER]
coal
charcoal
coal_block
- An unlabelled chest acts as a catch-all (accepts everything), so place it — or a chest labelled [ACS:TRASH], which deletes everything inserted into it — at the end of the line to mop up whatever the filtered chests ahead of it didn't claim.
3. Auto-refuelling your engines from sorted coal
Engines burn fuel, and the coal you just sorted in Example 2 can refuel them for free.
- Build a refuelling stop on the loop where the track passes under a chest with a hopper feeding down into it — engine carts act as a fuel-only storage, so a hopper above the track tops them off.
- Fill that chest from the coal chest your long-hopper sorter produced, so strip-mined coal cycles straight back into running the trains.
- Hold the train at the stop just long enough to load fuel. A timed signal works well:
[ACS:SIGNAL]
WAIT 5
- For a smarter version, gate it on the haul cycle — e.g. refuel only on the empty leg by pairing it with the unload stop. Remember engines only consume fuel while moving and burn at half the furnace rate (
engine.fuelBurnRateMultiplier: 0.5), so a short top-up each lap keeps them running indefinitely.
4. Passenger stations with checkpoint stops
The same signals make a passenger line that waits for riders and pauses at each station.
- Build trains of an engine cart + rideable/passenger carts. A station is just a stretch of track beside a platform.
- At each platform, hold the train briefly so passengers can board or hop off:
[ACS:SIGNAL]
WAIT 10
- To run a train only once it is full of riders, gate departure on
ALL_FULL_P — it stays red until every rideable cart has a player aboard, then goes green. Pair it with a WAIT so a partly-full train still leaves eventually instead of stranding riders:
[ACS:SIGNAL]
ALL_FULL_P
OR WAIT 60
- Lay the line as a loop with several stations, and run multiple engine trains around it spaced out by
NO_TRAIN signals (as in Example 1) so they never bunch up or collide.
- The result: each train pulls in, waits a few seconds for passengers at every checkpoint, then continues around the loop — a hands-free metro line.
Tip: because a driver cart overrides signals (and stops the engine from auto-driving), coupling a driver cart to a train and riding it lets you take manual control and drive it off the automated loop. Leave the driver cart off any train you want to keep running the loop on its own.
Mixing it all together
These build on each other: the strip-mine loop (1) feeds the long-hopper sorter (2), the sorted coal refuels the engines (3), and the same signal patterns drive a passenger network (4). Tune every limit — train length, hopper range, signal distances, wait times — in Configuration, and apply changes live with /acs reload.
Commands
AutoCartSystem provides a single base command.
/acs <subcommand> [args...]
- Aliases:
/autocart, /autocartsystem
- Base permission:
acs.command (default: all players)
Running /acs with no arguments (or /acs help) shows the in-game command list. See Permissions for the permission nodes.
/acs reload
Reloads the plugin: re-reads config.yml from disk and re-applies every setting at runtime. No server restart is needed for config changes to take effect.
|
|
| Syntax |
/acs reload |
| Permission |
acs.command.reload (default: op) |
| Example |
/acs reload |
/acs give
Gives an ACS item (a cart, or the long hopper block) to a player.
|
|
| Syntax |
/acs give <type> [amount] [player] |
| Permission |
acs.command.give (default: op) |
Arguments
| Arg |
Required |
Description |
type |
yes |
The item type (see table below). |
amount |
no |
How many items to give (minimum 1). Defaults to 1. |
player |
no |
Target player. Defaults to the sender; required when run from console. |
The optional arguments are positional but each is detected by its shape (integer, then a name), so they must appear in the order shown above. Every ACS cart can couple — there is no longer a coupling/non-coupling variant to choose.
Types (case-insensitive)
| Type |
Item given |
rideable |
Minecart |
driver |
Driver Cart |
chest |
Chest Minecart |
hopper |
Hopper Minecart |
furnace |
Furnace Minecart |
tnt |
TNT Minecart |
track_layer |
Auto Track Layer |
bridge_layer |
Auto Bridge Layer |
drill |
Drill Cart |
engine |
Engine Cart |
long_hopper |
Long Hopper (a hopper block item, not a cart) |
Examples
/acs give engine # 1 engine cart to yourself
/acs give drill # 1 drill cart to yourself
/acs give track_layer 16 # 16 track layers
/acs give chest 4 Steve # 4 chest minecarts to Steve
/acs give long_hopper 2 # 2 long hoppers to yourself
/acs info
Shows AutoCartSystem details for the cart you are riding, or — if you are not riding one — the cart you are looking at (within 6 blocks). Player-only.
Reported details include cart type, how many carts it is coupled to, drill pattern (drill carts only), and, when the cart belongs to a tracked train: train size, position in train, heading, whether the train has an engine or drill, regular chest count, functional cart count, and the current driver.
|
|
| Syntax |
/acs info |
| Permission |
acs.command.info (default: all players) |
| Example |
/acs info |
/acs help
Lists the subcommands above with their usage. Requires only the base acs.command permission.
|
|
| Syntax |
/acs help |
| Permission |
acs.command |
| Example |
/acs help |
Configuration
All numbers and most features can be enabled or disabled in the config file (plugins/AutoCartSystem/config.yml).
Most features have a enabled master toggle. Numeric limits are tunable. After editing the file, apply changes at runtime with /acs reload — no server restart required.
Coupling carts (coupling)
Controls placement-time coupling (and its placement highlight) that joins carts into a recognised "train".
| Key |
Purpose |
Type |
Default |
coupling.enabled |
Master toggle for coupling. When off, placed carts never couple, the placement highlight is hidden, and coupled trains lose their collision immunity. |
boolean |
true |
coupling.maxTrainLength |
Maximum number of carts in a single coupled train. No new carts couple once this length is reached. |
integer |
20 |
Auto Track Layer (trackLayer)
The track layer cart lays rail at the front of the train.
| Key |
Purpose |
Type |
Default |
trackLayer.enabled |
Master toggle for the track layer cart. |
boolean |
true |
trackLayer.lookAhead |
How many blocks ahead of the train front the layer looks to place rail. |
integer |
1 |
Auto Bridge Layer (bridgeLayer)
The bridge layer cart lays bridging blocks ahead of the train when crossing a gap.
| Key |
Purpose |
Type |
Default |
bridgeLayer.enabled |
Master toggle for the bridge layer cart. |
boolean |
true |
bridgeLayer.lookAhead |
How many blocks ahead of the train front the bridger looks to place a block. |
integer |
1 |
Drill Cart (drill)
The drill cart mines blocks directly ahead of the train in a configurable pattern.
| Key |
Purpose |
Type |
Default |
drill.enabled |
Master toggle for the drill cart. |
boolean |
true |
drill.defaultPattern |
Default mining pattern for newly created drill carts. One of: ONE_BY_TWO, TWO_BY_ONE, TWO_BY_TWO_RIGHT, TWO_BY_TWO_LEFT, THREE_BY_TWO, THREE_BY_THREE. |
string (enum) |
ONE_BY_TWO |
drill.pickaxeConsumptionMultiplier |
Pickaxes are consumed this many times faster than normal durability loss. |
decimal |
2.0 |
Engine Cart (engine)
The engine cart powers the train and can be driven by a player.
| Key |
Purpose |
Type |
Default |
engine.enabled |
Master toggle for the engine cart. |
boolean |
true |
engine.fuelBurnRateMultiplier |
Fuel burns at this fraction of the furnace rate (0.5 => fuel lasts twice as long). |
decimal |
0.5 |
engine.maxSpeed |
Maximum engine speed in blocks/tick. Vanilla minecart max speed is 0.4. |
decimal |
0.4 |
Long Hopper (longHopper)
The long hopper pushes items into chests far beyond the block directly adjacent to it.
| Key |
Purpose |
Type |
Default |
longHopper.enabled |
Master toggle for the long hopper. |
boolean |
true |
longHopper.range |
Maximum distance (in blocks) from the hopper output end to a target chest. |
integer |
20 |
longHopper.reach |
How far the long hopper reaches per tick when searching for a target. |
integer |
20 |
Recipes (recipes)
Controls the crafting recipes that produce ACS cart items (see Crafting recipes).
| Key |
Purpose |
Type |
Default |
recipes.enabled |
Master toggle for ACS cart crafting recipes. When false, carts are only obtainable via /acs give. |
boolean |
true |
Signs (signs)
Controls all ACS sign command handling.
| Key |
Purpose |
Type |
Default |
signs.enabled |
Master toggle for all ACS sign command handling (HOPPER, TRASH, SIGNAL). |
boolean |
true |
Signals (signals)
Controls engine train signal signs ([ACS:SIGNAL]).
| Key |
Purpose |
Type |
Default |
signals.enabled |
Master toggle for engine train signal signs. |
boolean |
true |
signals.noTrainMaxTracks |
Maximum tracks a NO_TRAIN condition may scan ahead. |
integer |
20 |
signals.waitMaxSeconds |
Maximum seconds a WAIT condition may specify. |
integer |
600 |
signals.scanAhead |
How many rail blocks ahead of the train front to scan for signal signs each tick. |
integer |
8 |
signals.stopDistance |
Distance (in blocks) over which an auto-driven train ramps down to a stop as it approaches a red signal. |
decimal |
6.0 |
Debug (debug)
| Key |
Purpose |
Type |
Default |
debug |
Enables verbose console logging (e.g. train front/heading changes) for troubleshooting. |
boolean |
false |
Permissions
AutoCartSystem declares the permission nodes below in plugin.yml. The default column shows who has the node out of the box:
true — granted to all players by default.
op — granted only to server operators by default.
Any node can be overridden per-group or per-player with your permissions plugin.
Placement and use
These control who can place ACS items to create the special carts (and the long hopper block).
| Node |
Grants |
Default |
acs.place |
Placing ACS items: cart items to create special carts, and the long hopper item to create a long hopper. |
true |
Signs
These control which ACS sign types a player may create.
| Node |
Grants |
Default |
acs.sign.hopper |
Creating [ACS:HOPPER] item-filter signs. |
true |
acs.sign.trash |
Creating [ACS:TRASH] signs. |
true |
acs.sign.signal |
Creating [ACS:SIGNAL] train signal signs. |
true |
Commands and admin
These control access to the /acs command and its subcommands.
| Node |
Grants |
Default |
acs.command |
Base access to the /acs command. |
true |
acs.command.info |
Using /acs info. |
true |
acs.command.reload |
Using /acs reload to reload configuration. |
op |
acs.command.give |
Using /acs give to spawn ACS cart items. |
op |
评论 0
登录后参与评分
还没有评论,来抢沙发吧