FauxPlayers
FauxPlayers 为 Minecraft 添加了仅用于显示的假玩家条目。
它支持:
- Paper 26.3(单个 Paper JAR 文件)。
- 适用于 Minecraft 26.2 和 26.3 的 Fabric。
- 服务器状态响应。
- 操纵游戏内玩家列表。
- 从其他服务器或 HTTP 源中继玩家。
- 将导出的 Discord 聊天历史记录重放至服务器。
- 模拟延迟、皮肤、头颅和 TAB 分数。
- 由兼容 OpenAI 的 API 驱动的假玩家对话与人格。
- 假玩家的死亡与击杀(以及其他假玩家相关行为)。
重要提示
假玩家是一个客户端显示条目。
它并非已连接的真实玩家。
FauxPlayers 不会创建:
- 网络连接;
- 实体;
- 登录或退出事件;
- 命令发送者;
- Bukkit Player 对象;
- 服务端玩家实例。
在 Paper 上,Bukkit.getOnlinePlayers() 仅包含真实玩家。
假条目不会改变权限、事件、槽位、限制或服务器 API。
其他玩家可以像查看正常玩家条目一样看到假条目。
它可以显示名称、显示名称、皮肤、头颅、游戏模式、延迟条以及 TAB 延迟分数。
这里的延迟是模拟生成的。
依赖要求
构建环境:
Paper 平台:
- Paper 26.3:需要 Java 25。
- ProtocolLib(用于 Paper 数据包功能)。
Fabric 平台:
- Minecraft 26.2 或 26.3。
- Fabric Loader 0.19.3 或更高版本。
- 针对 Minecraft 26.2 的 Fabric API 0.159.0+26.2 或更高版本。
- 针对 Minecraft 26.3 的 Fabric API 0.160.5+26.3 或更高版本。
- Java 25。
可选依赖:
服务器状态
FauxPlayers 可以更改发送给服务器列表客户端的数据。
它可以修改以下内容:
人数统计和名称样本是独立的值。
上游服务器可能报告有 30 名玩家,但仅提供五个名称。
FauxPlayers 不会为缺失的名称生成条目。
STATUS 数据不会创建网络连接。
它也不会改变服务器的实际登录容量。
游戏内玩家列表
FauxPlayers 向真实玩家发送玩家信息(player-info)数据包。
这些假条目仅存在于接收数据的客户端中。
显示的延迟控制着延迟条的显示。
它也控制着 TAB 插件中的 Ping: N 分数。
随机延迟可以按照配置的时间间隔同时更新这两个值。
若要显示 TAB 分数,请启用 TAB 的玩家列表目标:
playerlist-objective:
enabled: true
value: '%ping%'
fancy-value: '&7Ping: %ping%'
FauxPlayers 会在 Paper 和 Fabric 平台上发送 TAB-PlayerList 分数。
在 TAB 目标重载后,它会再次发送该分数。
TAB 的 %online% 值包含真实玩家和活跃的假 TAB 条目。
它不会改变服务器的真实玩家数量。
配置
生成的配置文件包含所有支持的设置。
以下是主要设置项:
enabled: true
status:
enabled: true
include-real-players: true
include-static-fakes: true
include-relayed-players: true
include-replay: true
count:
mode: COMBINED # FIXED, ADDITIONAL, RANDOM, REMOTE, 或 COMBINED
fixed: 20
tab:
enabled: true
include-static-fakes: true
include-relayed-players: true
include-replay: true
default-latency: 50
default-latency-range:
minimum: 50
maximum: 50
default-gamemode: SURVIVAL
outlier-ping:
count: 2 # 分配异常高延迟的随机假玩家数量;设为 0 则禁用。
minimum: 300
maximum: 1500
random-ping:
enabled: true
minimum: 20
maximum: 100
standard-deviation: 25
refresh-seconds: 30
static-players:
- name: Herobrine
latency: 42
relay:
enabled: false
source: STATUS # STATUS 或 HTTP
status:
host: 127.0.0.1
port: -1 # SRV 记录解析或端口 25565
http:
url: http://127.0.0.1:8080/players
refresh-seconds: 10
replay:
enabled: false
file: replay/chat.csv
speed: 1.0
loop: true
maximum-gap-seconds: 30
maximum-players: 100
chat: true
discord-chat: true
deaths: true
events: true
announce-seeks: true
skip-real-players: true
# 兼容 OpenAI 的实时人格聊天。API 密钥存储在此文件中。
personas:
enabled: true
mode: JOINED # JOINED 等待真实玩家加入;ALWAYS 在服务器启动后立即开始
endpoint: https://api.deepseek.com/chat/completions
api-key: "YOUR_DEEPSEEK_API_KEY"
model: deepseek-v4-flash
system-prompt-file: minecraft_chat_personas_system_prompt.md
persona-data-file: minecraft_chat_personas.json
interval-minimum-seconds: 30
interval-maximum-seconds: 75
# 仅在重放功能禁用时偶尔发生的纯文本假玩家死亡公告。
simulated-deaths:
enabled: false
人格聊天与模拟死亡
人格聊天在活跃的假玩家之间保持持续的对话,使用配置的兼容 OpenAI 的聊天补全端点。
真实玩家的消息会被作为上下文添加。每轮对话最多发送一行文本,下一轮对话会等待一个来自配置范围内的随机间隔。
生成的文本通常为小写,且大部分情况下会去除标点符号。
personas.mode: JOINED 会在最后一名真实玩家离开时暂停聊天,在有玩家加入后恢复,并在服务器变为空服时清除对话历史。
personas.mode: ALWAYS 会在服务器启动后立即开始,即使没有真实玩家在线也会继续运行。
提供的 Markdown 提示词和 JSON 名单会在首次使用时复制到配置文件夹中,并可在其中进行编辑。
只有当前活跃在标签页列表中的假玩家名称才能被生成为发言者;模型每轮最多返回一条简短消息。
在启动服务器之前,请将示例 DeepSeek 密钥替换为您自己的密钥。
simulated-deaths.enabled 启用偶尔发生的纯文本假玩家死亡公告,前提是重放功能已禁用。
这些是以聊天形式发布的公告;假玩家仍然只是显示条目,不会变成实体,也不会导致真正的游戏内死亡。
静态条目支持 name(名称)、display-name(显示名称)和 latency(延迟)。
静态和中继玩家的 UUID 是稳定的。
中继功能
中继功能从其他地方复制玩家列表,并将其作为假条目显示出来。
“其他地方”指的是由 relay.source 指定的来源。
relay.source: STATUS 会直接向Minecraft server发起询问,因此它会复用服务器列表中相同的公开 ping。将 relay.status.host 指向它即可。
relay.source: HTTP 会向你自己的 URL 请求 JSON,由你决定名单内容。将 relay.http.url 指向该地址即可。
两者都会写入相同的缓存名单,并且都会以虚假条目的形式显示。当你能提供完整名单时选择 HTTP;当你仅有另一台服务器信息时选择 STATUS。
中继请求在后台运行。
它们不会阻塞服务器线程。
禁用中继会停止显示其名称。上次获取的名单会保留在内存中,以便重新启用时无需再次请求即可直接使用,但在中继关闭期间不会从中显示任何内容。此时 /fauxplayers status 会报告 0 shown | 8 cached(显示 0 | 缓存 8),而不是暗示这些名称正在使用中。
STATUS 中继
将 relay.source 设置为 STATUS。
将 relay.status.host 设置为上游服务器。
FauxPlayers 会发送 Minecraft STATUS 请求。
如果存在 _minecraft._tcp SRV 记录,则会使用该记录。
否则,使用配置的端口。
当不存在 SRV 记录时,端口 -1 会使用 25565 端口。
STATUS 采样结果并非完整的名单。
FauxPlayers 不会将其用于加入或离开消息,因此 STATUS 中继永远不会产生虚假的加入或离开公告。只有 HTTP 源才会这样做。
HTTP 中继
将 relay.source 设置为 HTTP。
将 relay.http.url 设置为 JSON 端点。
推荐的响应格式:
{
"online": 3,
"max": 100,
"players": [
{"name": "Alice"},
{"name": "Bob"},
{"name": "Charlie"}
]
}
推荐使用 players 列表。
也接受扁平化的 name 字段。
当端点提供完整名单时使用 HTTP。
名单的变化可能会生成虚假的加入和离开消息。
被标记为 anonymous 或 Anonymous Player 的名称将被忽略。
FauxPlayers 不会解析或显示它们。
如果请求失败,启用 keep-last-successful-result 后,将保留上一次成功的名单。
加入和离开消息
将 messages.enabled 设置为 true 以公告 HTTP 名单的变化。
Paper 和 Fabric 会观察真实的加入和离开消息。
它们会复用该消息的格式来生成中继消息。
这支持自定义消息格式。
观察到的格式存储在 message-format.yml 中。
FauxPlayers 不会为虚假玩家创建 Bukkit 加入或退出事件。
真实玩家优先
真实玩家和虚假条目可能争夺同一个名称,因为重放的日志包含了当前在线的玩家。
当这种情况发生时,真实玩家保留所有权限,而虚假条目会被丢弃:
- 不会创建第二个条目,因此玩家列表和 TAB 菜单只显示一个条目,而不是两个。
- 不会以他们的名义发送重放的加入、离开或聊天消息,因此重放永远不会代表在场的人发言。
他们自己的条目和他们自己的话语始终优先。不区分大小写,因此当 Notch 在线时,重放的 notch 会被丢弃。
这涵盖了所有虚假条目的来源:静态的、中继的和重放的。
将 replay.skip-real-players 设置为 false 可以精确重放历史,即使其中提到了当前在线的人。
该检查每几个刻钟运行一次,因此当一个同名玩家登录且该名称的虚假条目正在显示时,真实玩家会接管该条目。
关闭某个模式
关闭某个模式会立即更新玩家列表并公告离开的玩家,方式与真实玩家退出的公告相同。
这两个目标是独立的。玩家列表是真实玩家在 TAB 菜单中看到的内容。状态采样是任何人连接前服务器列表所显示的内容。tab.* 设置仅影响前者,status.* 设置仅影响后者,而像 relay.enabled 这样的模式切换会影响两者。
| 开关 |
玩家列表 |
状态采样 |
enabled: false |
清空 |
清空 |
tab.enabled: false |
清空 |
不变 |
tab.include-static-fakes: false |
移除静态条目 |
不变 |
tab.include-relayed-players: false |
移除中继条目 |
不变 |
tab.include-replay: false |
移除重放条目 |
不变 |
relay.enabled: false |
移除中继条目 |
移除中继条目 |
replay.enabled: false |
移除重放条目 |
移除重放条目 |
status.enabled: false |
不变 |
完全不受影响 |
status.include-static-fakes: false |
不变 |
移除静态条目 |
status.include-relayed-players: false |
不变 |
移除中继条目 |
status.include-replay: false |
不变 |
移除重放条目 |
status.enabled: false 是唯一一个让采样结果保持不变而非清空它的选项,因为此时状态响应就是服务器自身的响应。
玩家列表每几个刻钟重建一次,因此更改会在命令发出后瞬间生效。重新开启某个模式会公告其添加的玩家。对列表没有影响的更改(例如编辑 replay.speed 或添加文本替换)不会产生任何消息。
公告的是配置更改本身造成的差异。只有因它而发生变化的条目才会被公告,因此如果一个命令没有触及玩家列表的任何部分,即使中继名单或重放正在变化,它也会保持静默。
在服务器启动时的首次加载不会有任何公告,因为没有之前的列表可供比较。将 messages.enabled 设置为 false 可以在不发送任何消息的情况下移除条目。
禁用中继会将其获取的名单保留在内存中,以便重新启用时无需新请求即可再次使用,但在其关闭期间不会从中显示任何内容。
命令
使用 /fauxplayers。
/fp 和 /fakeplayers 是其别名。
| 命令 |
功能 |
/fauxplayers status |
显示真实玩家、中继、回放、人格模拟、模拟死亡和延迟范围的状态。API 密钥始终隐藏。 |
/fauxplayers list |
列出静态和中继缓存的名称。 |
/fauxplayers reload |
重新加载配置。 |
/fauxplayers refresh |
启动中继刷新。 |
/fauxplayers add <name> |
添加静态条目。 |
/fauxplayers remove <name> |
移除静态条目。 |
/fauxplayers ping <name> <ms> |
设置静态延迟。 |
/fauxplayers outlierping <count> |
随机选择指定数量的活跃假人玩家以产生高延迟;设为 0 则禁用此功能。 |
/fauxplayers outlierping set <min>-<max> |
设置有界正态分布的高延迟范围(默认 300-1500)。 |
/fauxplayers pingrange set <min>-<max> |
设置普通假人玩家的随机延迟范围。 |
/fauxplayers defaultping set <min>-<max> |
设置未明确指定延迟的静态条目的默认延迟范围。 |
/fauxplayers personas status |
显示人格状态、请求计数以及最新结果或错误。 |
/fauxplayers set personas.mode JOINED |
仅在真实玩家在线时聊天。使用 ALWAYS 可从服务器启动开始运行。 |
/fauxplayers say <name> <message> |
发送虚假聊天文本。 |
/fauxplayers get <setting> |
显示某项设置。 |
/fauxplayers set <setting> <value> |
更改某项设置。 |
/fauxplayers relay |
显示中继状态。 |
/fauxplayers relay enable |
启用中继。 |
/fauxplayers relay disable |
禁用中继。 |
/fauxplayers replay |
显示回放状态及子命令列表。 |
/fauxplayers replay enable |
启用回放。 |
/fauxplayers replay disable |
禁用回放。 |
/fauxplayers replay restart |
重新读取文件并从头开始。 |
/fauxplayers replay seek <line> |
跳转到指定行。 |
/fauxplayers replay skip <lines> |
按行数移动,负数表示后退。 |
/fauxplayers replay replace <from>=<to> |
添加文本重写规则。 |
/fauxplayers replay unreplace <from> |
移除文本重写规则。 |
/fauxplayers replay replacements |
列出文本重写规则。 |
/fauxplayers replay speed <multiplier> |
设置时间线速度。 |
/fauxplayers replay loop <true|false> |
设置循环模式。 |
/fauxplayers replay file <path> |
设置 CSV 文件路径。 |
两个平台均提供命令补全功能。
Paper 需要 fauxplayers.admin 权限。
Fabric 需要服务器操作员权限级别。
非操作员无法发现 FauxPlayers
对于非操作员而言,FauxPlayers 的命令并不存在:
- 根命令和别名不会出现在命令树数据包中。
- 自动补全回复永远不会包含这些命令,即使客户端发送了原始建议请求(如
/f、/fa 或 /fp)。Paper 通过 ProtocolLib 从建议数据包中剥离它们;Fabric 在构建任何回复之前于命令分发器处进行过滤。
- 执行这些命令会报告“未知命令”,且补全功能无返回。
- 操作员不受影响。
在 Paper 上,建议数据包过滤器需要 ProtocolLib。
命令树移除和执行守卫无需依赖即可工作。
回放
回放读取 Discord 聊天导出文件,并按原始顺序将其播放到服务器中。到达末尾后,除非 replay.loop 为 false,否则将重新开始。
该文件是 Discord 频道导出文件,包含 AuthorID、Author、Date、Content、Attachments 和 Reactions 列。仅使用 Author、Date 和 Content。
除非 replay.file 是绝对路径,否则它相对于插件数据文件夹。
- Paper:
plugins/FauxPlayers/replay/chat.csv。
- Fabric:
config/fauxplayers/replay/chat.csv。
随着回放进行,位置会被保存,因此服务器重启后会从中断处继续,而不是从头开始。保存的位置与文件相邻,名为 chat.csv.position,因此更改 replay.file 会使新文件从头开始。/fauxplayers replay restart 从头开始并清除保存的位置。关闭回放会保留位置,因此重新开启时会恢复进度。
回放内容
X joined the game 添加 X 这个假人条目并广播加入消息。
X left the game 移除该条目并广播离开消息。
这两种形式也会被识别为 X has joined the server 格式。
死亡消息是根据其内容读取的,而不是根据发布者,因为任何一方账号都可以携带该消息。无论导出文件将其归功于谁,X was slain by Y using [Z]、X fell from a high place 和 X drowned 都会作为死亡消息回放。
受害者必须是曾加入服务器的名称,因此会检查 X 是否在该列表中。仅提及死亡的聊天(如 i blew up the front 或 brodie fell for the ragebait)仍被视为普通聊天,因为第一个词不是玩家名称。
服务器关闭、重启、状态信息、控制台输出和权限错误会被完全丢弃。
回放的玩家是正常的假人条目。FauxPlayers 会根据名称解析 Mojang UUID、名称大小写和皮肤,因此他们的头像和图标是真实的。他们永远不会成为真正的服务器玩家。
头像查找会不断重试。如果某个名称解析失败,会再次尝试获取,直到解析成功,一旦获得真实皮肤就会重建头像。
两个聊天来源
频道同时包含游戏内聊天和 Discord 聊天,导出文件通过发布行的账号来区分它们,而不是通过文本中的名称。
存在两个账号:
- 服务器机器人 发布加入、离开、死亡、服务器输出以及以
Player: message 格式编写的游戏内聊天。
- 中继账号 以 玩家自己的名称 发布游戏内聊天。随着时间的推移,这些服务器已从第一种风格切换到第二种风格,因此导出文件通常同时包含两者。
Discord 用户以其自己的账号和 Discord 用户名发帖。该用户名通常是玩家游戏内名称的小写版本,这就是为什么仅凭名称无法确定身份的原因。
FauxPlayers 从 AuthorID 列读取账号信息:
- 机器人是那个以非玩家名义发布加入消息的账号。中继器也会发布加入消息,但它是以下线玩家自己的名字发布的,因此不会与机器人混淆。
- 中继器是一个使用许多不同名字发布的账号,这些名字属于曾经加入服务器的玩家。Discord 账号始终只使用一个名字发布,因此它永远不会符合条件。
- 只要中继消息的名字是玩家名字(由于中继器是以玩家自己的名字发布的,这总是成立),该中继消息就被视为游戏内聊天。名字不需要出现在加入消息中,因此即使导出文件片段在某人加入之后开始,仍然能正确归因于其聊天内容。
其余部分均为 Discord 聊天。
未归因的消息
服务器机器人是服务器自身的账号,因此它永远不会代表自己发言。它仅传递加入、离开、死亡、服务器输出或格式为 Player: message 的游戏内聊天。
因此,没有关联玩家的机器人行即为未归因的中继消息,这意味着名字在传输过程中丢失了。FauxPlayers 会忽略这些消息而不是显示它们,从而防止服务器看起来像在自言自语地说出诸如 nothing 之类的内容。
游戏内聊天行通过其 Player: message 结构来识别,且玩家不必是导出文件中记录过加入的人。因此,即使在一个从未显示 FieryGrowth 登录的文件中,FieryGrowth: wsp 也会作为来自 FieryGrowth 的聊天回放。某些服务器使用的带前导点的名称会被去除前导点。
中继器同样适用此规则,因为它以玩家自己的名字发布,所以其消息根据该名字进行归因。如果某行的名字根本不能是玩家名字(例如括号包裹的内容),则保留为服务器输出。
游戏内聊天显示为 <Player> message,Discord 聊天显示为 [Discord] <user> message。
Discord 用户不在游戏中,所以他们永远不会成为玩家条目,也不会获得玩家头像。只有加入和离开消息会创建回放中的玩家,并且这些消息对应的是游戏内的账号。
设置 replay.discord-chat 为 false 可以排除 Discord 对话,仅重放服务器上发生的内容。设置 replay.chat 为 false 则可以丢弃游戏内聊天。
运行 /fauxplayers replay 可查看已检测到的账号列表。
跳转定位
/fauxplayers replay 将位置显示为 Lines: 2/547884,其中数字表示已经跳过的行数。跳转使用相同的编号系统:
/fauxplayers replay seek 30000 跳转到该行。
/fauxplayers replay skip 5000 向前移动五千行。
/fauxplayers replay skip -5000 向后移动五千行。
跳转会根据该行之前的加入和离开消息重新构建玩家列表,而不是重放这些消息,因此名单、玩家数量和 TAB 列表会立即正确反映该时刻的状态。
随后,跳转会以正常的名单变更形式宣布:在旧行在场但在新行不在场的玩家离开,而仅在新行在场的玩家加入。因此,跳跃的效果与其他玩家列表变更相同,而不是让列表毫无解释地闪烁。
如果某玩家的加入行位于跳转点之前,则该玩家已在列表中,不会再次加入,但其随后的离开消息仍会将其移除。聊天与玩家列表始终保持同步:跳转后发言的所有人都已经在名单中。
设置 replay.announce-seeks 为 false 可实现静默跳转,在不发送消息的情况下保持名单正确。
文本替换
可以在回放过程中重写行,这对于在任何人看到之前清除短语、侮辱性用语、链接或名字非常有用。这一功能有时也被称为过滤。
运行 /fauxplayers replay 以查看完整的子命令列表,该列表由自动补全所基于的同一列表生成:
Use /fauxplayers replay <enable|disable|file|speed|loop|restart|seek|skip|chat
|discord-chat|deaths|events|maximum-gap-seconds|maximum-players|replace|unreplace
|replacements> ...
replay:
replacements:
- from: "annoying phrase"
to: "replacement"
- from: "discord.gg/abcdef"
to: ""
每个 from 都作为字面文本进行匹配,区分大小写,所有出现的情况都会被替换。空的 to 值会删除匹配项。
规则在整行回放之前应用于游戏内聊天、Discord 聊天、死亡消息和其他服务器输出。匹配发生在行分类之后,因此重写绝不会将加入消息变成聊天消息或隐藏死亡事件。
在游戏中:
/fauxplayers replay replace <from>=<to> 添加一条规则。第一个 = 用于分隔,因此两侧都可以包含空格。
/fauxplayers replay unreplace <from> 移除一条规则。
/fauxplayers replay replacements 列出所有规则。
更改后运行 /fauxplayers replay restart 以重建已加载的行。
读取状态
/fauxplayers replay 提供足够的信息来区分正在等待的重放和停滞的重放:
Replay » enabled=true | file=legacy.csv | speed=1.0 | loop=true
Lines: 28/547884 | players: 3 | finished: false
Clock: 2h 14m of 373d 4h 0m | next line in 12s | ticks driven: 8420
- Lines 统计已重放的行数,出自文件中的总行数。它从 0 开始,第一行在启用后的第一个刻被分发。
- Clock 表示重放已到达原始时间线的进度,相对于整个时间线。
- next line in 表示下一行预期的等待时间。较大的数值表示重放正在播放安静的时段,而非出现问题。可使用
skip 跳过。
- ticks driven 统计游戏循环驱动重放的次数。该数值必须持续增加。如果数值从不变化,意味着循环未运行,这是一个值得报告的问题,因为即使重放处于等待状态,也会计算刻数。
速度和间隔
默认情况下,回放是实时的。replay.speed 会压缩时钟:设置为 10 表示每真实一秒回放十秒的历史记录。
长时间的静默期可能导致回放等待很久。默认情况下,replay.maximum-gap-seconds 为 0,这会禁用上限并完全保留 CSV 时间戳。将其设置为正数可以限制对任意单行记录的等待时间;例如,设置为 30 会将两天的中断压缩为三十秒的暂停。
这些受限的等待时间是累积的,因此每个静默期只产生一次暂停。原本间隔一秒的行在回放时仍然保持一秒的间隔,即使在受限的中断之后也是如此。较低的值会压缩长时间的等待,而较高的值则会保留更多的静默内容。这也影响静默和空白时段:当没有任何玩家在线时,行之间的等待时间也会以相同的方式被限制。
在禁用间隙上限且速度为 1.0 时,回放时间与 CSV 时间线一致。示例导出覆盖 373 天;若设为 100,则大约需要 3.7 天;若设为 1000,则大约需要 9 小时。
回放每秒最多输出 200 行数据(即每刻约 4000 行),因此极高的速度最终会稳定在该速率,而不会更快。
排序注意事项
replay.chat 回放游戏内聊天,replay.discord-chat 回放 Discord 聊天,
replay.deaths 回放死亡消息,replay.events 回放服务器输出的其余部分。关闭其中一项可以让频道更安静。
replay.maximum-players 限制同时列出的已回放玩家数量。
超过限制的球员仍然可以聊天,但不会获得玩家列表条目。
- 导出文件仅在启动时解析一次。更改
replay.chat、
replay.discord-chat、replay.deaths、replay.events 或
replay.maximum-gap-seconds 后,运行 /fauxplayers replay restart。
- 标记为
Server 的中继行(即服务器关于自身的发言)会以 Server 的名义作为聊天回放。该标签是导出文件中的称呼,并非真实的账户。
- 某些服务器会将自身聊天转发到 Discord,随后又撤回。回声会产生包含相同文字的第二行,因此会被回放两次。对于双方账号都携带的死亡事件也会发生同样的情况。
- 涵盖当前在线人员的回放会省略他们的行。参见上文“真实玩家”部分。
Discord 昵称与游戏内名称可能不同。回放会保留导出文件中使用的原始名称。
故障排除
假名未显示
检查 status.enabled 和 tab.enabled。
检查相关的 include-* 设置。
检查服务器日志中是否存在数据包或 TAB 错误。
TAB 显示仅一名在线玩家
确认 TAB 插件已安装并启用。
确认 tab.enabled 为 true。
服务器的真实在线人数保持不变。
Ping: N 分数未显示
启用 TAB 的玩家列表目标(objective)。
安装重新编译的 JAR 包。
重启服务器。
中继数据过时
运行 /fauxplayers status。
检查缓存年龄和最后一条错误信息。
运行 /fauxplayers refresh。
检查主机、端口、URL、超时时间和中继源。
回放已启用但无反应
运行 /fauxplayers replay 并查看数值。
Loaded: (none) 表示文件尚未读取,或者路径错误。
大型导出文件在解析第一行回放前需要几秒钟。
next line in 倒计时指向一个较大的数值,意味着回放正在播放历史记录中的静默时段。这是忠实跟随文件的表现。使用 /fauxplayers replay skip <lines> 跳过它,或降低
replay.maximum-gap-seconds。
ticks driven 冻结意味着游戏循环未驱动回放。服务器日志中将包含一条警告,指明原因,因为循环中的失败会被报告出来,而不是静默停止。
回放未启动
运行 /fauxplayers replay。
检查 replay.enabled 和解析后的 file 路径。
检查最后一条错误信息和服务器日志。
更改文件或文本替换(也称为过滤器)后,运行 /fauxplayers replay restart。
首次加载会在后台解析整个文件。
大型导出文件在回放第一行之前需要几秒钟的时间。
回放的玩家头像为默认头像
只有当名称解析为 Mojang 账户时,头像才是真实的。FauxPlayers 会不断尝试询问:如果名称解析失败,每二十秒重试一次;一旦收到真实的皮肤数据,已发送的头像会立即重建,因此在会话期间不会出现永久错误的头像。
Mojang 查询通过插件自带的 HTTP 客户端进行,并具有宽松的超时设置。
缓慢的回复永远不会被视为“无此账户”;只有收到 404 或 204 响应时才会这样认定,即便如此,名称仍会重试,只是频率较低。
有三种情况会导致头像无法变为真实状态。
- 自导出文件生成以来,账户已被重命名或删除。Mojang 仅解析当前名称,因此旧日志中的名称可能会返回 404,且无法恢复皮肤。这些名称仍会重试,但仅每十分钟一次,因为更频繁地询问并无帮助。这对该名称而言是永久性的。
- 查询被限速。Mojang 会对大量名称查询请求返回 HTTP 429。FauxPlayers 会分散其查询间隔,且从不记住失败,因此被限速的名称会被重试,并且头像很快会填充完毕。
- Mojang 响应缓慢或不可达。查询会被重试,并在成功时重建头像。
第一次发生时,日志中的警告会指明原因。
许可证
FauxPlayers 根据 GNU 通用公共许可证第 3 版发布。
FauxPlayers
FauxPlayers adds display-only player entries to Minecraft.
It supports:
- Paper 26.3 (single Paper JAR).
- Fabric for Minecraft 26.2 and 26.3.
- Server status responses.
- Manipulating the in-game player list.
- Relaying players from another server or HTTP source.
- Replaying an exported Discord chat history into the server.
- Simulated ping, skins, heads, and TAB scores.
- Fake player conversations and personas powered by an OpenAI compatible API.
- Fake player deaths and kills (among other fake players).
Important
A fake player is a client display entry.
It is not a connected player.
FauxPlayers does not create:
- a connection;
- an entity;
- a login or quit event;
- a command sender;
- a Bukkit Player;
- a server-side player.
On Paper, Bukkit.getOnlinePlayers() contains only real players.
Fake entries do not change permissions, events, slots, limits, or server APIs.
Other players can see a fake entry like a normal player entry.
It can show a name, display name, skin, head, game mode, ping bars, and a TAB ping score.
The ping is simulated.
Requirements
Build:
Paper:
- Paper 26.3: Java 25.
- ProtocolLib for Paper packet features.
Fabric:
- Minecraft 26.2 or 26.3.
- Fabric Loader 0.19.3 or later.
- Fabric API 0.159.0+26.2 or later for Minecraft 26.2.
- Fabric API 0.160.5+26.3 or later for Minecraft 26.3.
- Java 25.
Optional:
- TAB for TAB integration on both platforms.
Server status
FauxPlayers can change the data sent to server-list clients.
It can change:
- the online count;
- the maximum count;
- the sample names.
The count and name sample are separate values.
An upstream server can report 30 players and provide five names.
FauxPlayers does not create the missing names.
STATUS data does not create connections.
It does not change the server login capacity.
In-game player list
FauxPlayers sends player-info packets to real players.
The fake entries exist in the receiving client only.
The displayed latency controls the ping bars.
It also controls the TAB Ping: N score.
Random ping can update both values at the configured interval.
To show the TAB score, enable the TAB player-list objective:
playerlist-objective:
enabled: true
value: '%ping%'
fancy-value: '&7Ping: %ping%'
FauxPlayers sends the TAB-PlayerList score on Paper and Fabric.
It sends the score again after a TAB objective reload.
The TAB %online% value includes real players and active fake TAB entries.
It does not change the server's real player count.
Configuration
The generated file contains all supported settings.
These are the main settings:
enabled: true
status:
enabled: true
include-real-players: true
include-static-fakes: true
include-relayed-players: true
include-replay: true
count:
mode: COMBINED # FIXED, ADDITIONAL, RANDOM, REMOTE, or COMBINED
fixed: 20
tab:
enabled: true
include-static-fakes: true
include-relayed-players: true
include-replay: true
default-latency: 50
default-latency-range:
minimum: 50
maximum: 50
default-gamemode: SURVIVAL
outlier-ping:
count: 2 # Random faux players assigned unusually high pings; 0 disables.
minimum: 300
maximum: 1500
random-ping:
enabled: true
minimum: 20
maximum: 100
standard-deviation: 25
refresh-seconds: 30
static-players:
- name: Herobrine
latency: 42
relay:
enabled: false
source: STATUS # STATUS or HTTP
status:
host: 127.0.0.1
port: -1 # SRV or port 25565
http:
url: http://127.0.0.1:8080/players
refresh-seconds: 10
replay:
enabled: false
file: replay/chat.csv
speed: 1.0
loop: true
maximum-gap-seconds: 30
maximum-players: 100
chat: true
discord-chat: true
deaths: true
events: true
announce-seeks: true
skip-real-players: true
# OpenAI-compatible live persona chat. The API key is stored in this file.
personas:
enabled: true
mode: JOINED # JOINED waits for a real player; ALWAYS starts after server startup
endpoint: https://api.deepseek.com/chat/completions
api-key: "YOUR_DEEPSEEK_API_KEY"
model: deepseek-v4-flash
system-prompt-file: minecraft_chat_personas_system_prompt.md
persona-data-file: minecraft_chat_personas.json
interval-minimum-seconds: 30
interval-maximum-seconds: 75
# Occasional text-only faux-player deaths, only when replay is disabled.
simulated-deaths:
enabled: false
Persona chat and simulated deaths
Persona chat keeps one ongoing conversation between active faux players, using
the configured OpenAI-compatible chat-completions endpoint. Real-player messages
are added as context. Each turn sends at most one line, and the next turn waits a random interval from the configured range. Generated lines are usually lowercase
and punctuation is stripped most of the time.
personas.mode: JOINED pauses chat when the last real player leaves, starts it
after a player joins, and clears the conversation history when the server empties.
personas.mode: ALWAYS starts after server startup and continues even when no
real players are online. The supplied Markdown prompt and JSON roster are
copied to the config folder on first use and can be edited there. Only active
tab-list faux names can be generated as speakers; the model returns at most one
short message per turn. Replace the example DeepSeek key with your
own key before starting the server.
simulated-deaths.enabled enables occasional text-only faux-player death
announcements while replay is disabled. These are chat announcements; faux
players remain display entries and do not become entities or cause actual game
deaths.
Static entries support name, display-name, and latency.
Static and relayed UUIDs are stable.
Relays
A relay copies the player list from somewhere else and shows it as fake entries.
The somewhere else is whatever relay.source names.
relay.source: STATUS asks the upstream Minecraft server directly, so it
reuses the same public ping in the server list. Point relay.status.host at it.
relay.source: HTTP asks your own URL for JSON, so you choose the roster.
Point relay.http.url at it.
Both write the same cached roster, and both are shown as fake entries. Choose
HTTP when you can serve a complete list; choose STATUS when you only have the
other server.
Relay requests run in the background.
They do not block the server thread.
Disabling the relay stops its names being shown. The roster it last fetched is
kept in memory so re-enabling uses it again without a fresh request, but nothing
is displayed from it while the relay is off. /fauxplayers status reports
0 shown | 8 cached in that state rather than implying the names are in use.
STATUS relay
Set relay.source to STATUS.
Set relay.status.host to the upstream server.
FauxPlayers sends a Minecraft STATUS request.
It uses an _minecraft._tcp SRV record when available.
Otherwise, it uses the configured port.
Port -1 uses port 25565 when no SRV record exists.
STATUS samples are not complete rosters.
FauxPlayers does not use them for join or leave messages, so a STATUS relay never
produces fake join or leave announcements. Only the HTTP source does.
HTTP relay
Set relay.source to HTTP.
Set relay.http.url to the JSON endpoint.
Recommended response:
{
"online": 3,
"max": 100,
"players": [
{"name": "Alice"},
{"name": "Bob"},
{"name": "Charlie"}
]
}
The players list is recommended.
A flat name field is also accepted.
Use HTTP when the endpoint provides a complete roster.
Roster changes can create fake join and leave messages.
Names classified as anonymous or Anonymous Player are ignored.
FauxPlayers does not resolve or display them.
If a request fails, keep-last-successful-result keeps the last good roster when enabled.
Join and leave messages
Set messages.enabled to true to announce HTTP roster changes.
Paper and Fabric observe a real join and leave message.
They reuse its format for relay messages.
This supports custom message formats.
The observed format is stored in message-format.yml.
FauxPlayers does not create Bukkit join or quit events for fake players.
Real players win
A real player and a fake entry can want the same name, because a replayed log
holds people who are on the server right now.
When that happens the real player keeps everything and the fake one is dropped:
- No second entry is created, so the player list and TAB show one entry, not two.
- No replayed join, leave, or chat is sent under their name, so the replay never
speaks for someone who is present.
Their own entry and their own words always win. Case does not matter, so a
replayed notch is dropped while Notch is online.
This covers every source of fake entries: static, relayed, and replayed.
Set replay.skip-real-players to false to replay the history exactly as it
happened, even where it names someone who is online.
The check runs every few ticks, so a player who logs in while a fake entry of
that name is showing takes over the entry.
Turning a mode off
Switching a mode off updates the player list straight away and announces the
players leaving, the same way a real player quitting is announced.
The two targets are separate. The player list is what real players see in TAB.
The status sample is what the server-list shows before anyone connects. A
tab.* setting changes only the first, a status.* setting changes only the
second, and a mode switch such as relay.enabled changes both.
| Toggle |
Player list |
Status sample |
enabled: false |
emptied |
emptied |
tab.enabled: false |
emptied |
unchanged |
tab.include-static-fakes: false |
static entries removed |
unchanged |
tab.include-relayed-players: false |
relayed entries removed |
unchanged |
tab.include-replay: false |
replayed entries removed |
unchanged |
relay.enabled: false |
relayed entries removed |
relayed entries removed |
replay.enabled: false |
replayed entries removed |
replayed entries removed |
status.enabled: false |
unchanged |
left entirely alone |
status.include-static-fakes: false |
unchanged |
static entries removed |
status.include-relayed-players: false |
unchanged |
relayed entries removed |
status.include-replay: false |
unchanged |
replayed entries removed |
status.enabled: false is the one that leaves the sample untouched rather than
emptying it, because the status response is then the server's own.
The player list is rebuilt every few ticks, so a change lands within a moment of
the command. Turning a mode back on announces the players it adds. A change that
leaves the list alone, such as editing replay.speed or adding a text
replacement, costs no messages.
What is announced is the difference the configuration change itself makes.
Only the entries that change because of it are announced, so a command that
touches nothing about the player list stays silent even while the relay roster or
the replay is changing underneath it.
Nothing is announced on the first load at server start, because there is no
previous list to compare against. Set messages.enabled to false to remove
entries without any message.
Disabling the relay keeps its fetched roster in memory so re-enabling uses it
again without a new request, but nothing is displayed from it while it is off.
Commands
Use /fauxplayers.
/fp and /fakeplayers are aliases.
| Command |
Function |
/fauxplayers status |
Shows real, relay, replay, persona, simulated-death, and ping-range state. The API key is always hidden. |
/fauxplayers list |
Lists static and cached relay names. |
/fauxplayers reload |
Reloads the configuration. |
/fauxplayers refresh |
Starts a relay refresh. |
/fauxplayers add <name> |
Adds a static entry. |
/fauxplayers remove <name> |
Removes a static entry. |
/fauxplayers ping <name> <ms> |
Sets a static ping. |
/fauxplayers outlierping <count> |
Randomly selects that many active faux players for high pings; 0 disables it. |
/fauxplayers outlierping set <min>-<max> |
Sets the bounded, normally distributed outlier ping range (default 300-1500). |
/fauxplayers pingrange set <min>-<max> |
Sets the random ping range for ordinary faux players. |
/fauxplayers defaultping set <min>-<max> |
Sets the default latency range for static entries without an explicit latency. |
/fauxplayers personas status |
Shows persona status, request count, and the latest result or error. |
/fauxplayers set personas.mode JOINED |
Chat only while real players are online. Use ALWAYS to run from server startup. |
/fauxplayers say <name> <message> |
Sends fake chat text. |
/fauxplayers get <setting> |
Shows a setting. |
/fauxplayers set <setting> <value> |
Changes a setting. |
/fauxplayers relay |
Shows relay state. |
/fauxplayers relay enable |
Enables the relay. |
/fauxplayers relay disable |
Disables the relay. |
/fauxplayers replay |
Shows replay state and the sub-command list. |
/fauxplayers replay enable |
Enables the replay. |
/fauxplayers replay disable |
Disables the replay. |
/fauxplayers replay restart |
Re-reads the file and starts over. |
/fauxplayers replay seek <line> |
Jumps to a line. |
/fauxplayers replay skip <lines> |
Moves by lines, negative goes back. |
/fauxplayers replay replace <from>=<to> |
Adds a text rewrite. |
/fauxplayers replay unreplace <from> |
Removes a text rewrite. |
/fauxplayers replay replacements |
Lists the text rewrites. |
/fauxplayers replay speed <multiplier> |
Sets the timeline speed. |
/fauxplayers replay loop <true|false> |
Sets the loop mode. |
/fauxplayers replay file <path> |
Sets the CSV path. |
Both platforms provide command completion.
Paper requires fauxplayers.admin.
Fabric requires the server-operator permission level.
Non-operators cannot discover FauxPlayers
For a non-operator, the FauxPlayers commands do not exist:
- The roots and aliases are absent from the command-tree packet.
- Autocomplete replies never contain them, even when the client sends raw
suggestion requests such as
/f, /fa, or /fp. Paper strips them from the
suggestion packet with ProtocolLib; Fabric filters them at the command
dispatcher before any reply is built.
- Executing them reports an unknown command, and completion returns nothing.
- Operators are unaffected.
On Paper, the suggestion-packet filter requires ProtocolLib.
The command-tree removal and the execution guard work without it.
Replay
Replay reads a Discord chat export and plays it back into the server in the
original order. When the end is reached it starts over unless replay.loop is
false.
The file is a Discord channel export with the columns AuthorID, Author,
Date, Content, Attachments, and Reactions. Only Author, Date, and
Content are used.
replay.file is relative to the plugin data folder unless it is absolute.
- Paper:
plugins/FauxPlayers/replay/chat.csv.
- Fabric:
config/fauxplayers/replay/chat.csv.
The position is saved as the replay advances, so a server restart carries on from
where it stopped instead of starting at the first line. The saved position sits
beside the file, as chat.csv.position, so changing replay.file starts the new
file from the beginning. /fauxplayers replay restart starts over from the first
line and clears the saved position. Switching the replay off keeps the position,
so turning it back on resumes.
What is replayed
X joined the game adds the X fake entry and broadcasts the join message.
X left the game removes the entry and broadcasts the leave message.
Both are recognised in the X has joined the server form as well.
A death message is read from what it says, not from who posted it, because either
account can carry it. X was slain by Y using [Z], X fell from a high place,
and X drowned replay as death messages whoever the export credits them to.
The victim has to be a name that joined the server, so X is checked against
that list. Chat that merely mentions dying, such as i blew up the front or
brodie fell for the ragebait, stays chat, because the first word is not a
player.
Server shutdown, restart, status, console output, and permission errors are
dropped entirely.
Replayed players are normal faux entries. FauxPlayers resolves the Mojang UUID,
the name casing, and the skin from the name, so their head and icon are real.
They are never server players.
Head lookups keep being retried. A name that failed is asked for again until it
resolves, and a head is rebuilt as soon as the real skin arrives.
The two chat sources
The channel holds both in-game chat and Discord chat, and the export separates
them by which account posted the line, not by the name in the text.
Two accounts exist:
- The server bot posts joins, leaves, deaths, server output, and in-game chat
written as
Player: message.
- The relay account posts in-game chat under the player's own name. Over
time these servers switched from the first style to the second, so an export
usually contains both.
A Discord user posts under their own account, under their own Discord handle.
That handle is often a lowercase version of a player's in-game name, which is
why the name alone cannot decide it.
FauxPlayers reads the account from the AuthorID column:
- The bot is the account that posts the join lines under a name that is not a
player. The relay posts join lines too, but it posts them under the joining
player's own name, so those are not mistaken for the bot.
- The relay is an account that posts under many different names, and those names
belong to people who joined the server. A Discord account only ever posts under
one name, so it never qualifies.
- A relayed line counts as in-game chat whenever its name is a player name, which it is by
construction because the relay posts under the player's own name. The name does not
have to appear in a join line, so a slice of an export that starts after somebody
joined still attributes their chat correctly.
Anything left is Discord chat.
Unattributed messages
The server bot is the server's own account, so it never chats on its own behalf.
It only ever carries a join, a leave, a death, server output, or in-game chat
written as Player: message.
A bot line that has no player on it is therefore an unattributed relay, where the
name was lost on the way through. FauxPlayers ignores those instead of showing
them, which is what keeps the server from appearing to say things like
nothing on its own.
An in-game chat line is recognised by its Player: message shape, and the player
does not have to be one the export recorded joining. So FieryGrowth: wsp
replays as chat from FieryGrowth even in a file that never shows them logging
in. A name written with a leading dot, as some servers do, is trimmed.
The same applies to the relay, which posts under the player's own name, so its
lines are attributed from that name. A line whose name cannot be a player name at
all, such as one wrapped in brackets, stays server output.
In-game chat shows as <Player> message and Discord chat as
[Discord] <user> message.
Discord users are not in the game, so they never become player entries and they
never get a player head. Only the join and leave lines create replayed players,
and those name in-game accounts.
Set replay.discord-chat to false to leave the Discord conversation out and
replay only what happened on the server. Set replay.chat to false to drop
the in-game chat instead.
Run /fauxplayers replay to see which accounts were detected.
Seeking
/fauxplayers replay shows the position as Lines: 2/547884, where the figure
counts the lines already passed. Seeking uses the same numbering:
/fauxplayers replay seek 30000 jumps to that line.
/fauxplayers replay skip 5000 moves forward five thousand lines.
/fauxplayers replay skip -5000 moves back five thousand lines.
Seeking rebuilds the player list from the joins and leaves before that line
instead of replaying them, so the roster, the player count, and the TAB list are
correct for that moment straight away.
The jump is then announced as a normal roster change: players who were in the
game at the old line and are not at the new one leave, and players who are only
at the new line join. A leap therefore reads the same way as any other change to
the player list, rather than the list flickering with no explanation.
A player whose join line sits before the seek point is already listed and does
not join again, and their next leave line still removes them. Chat is never out
of step with the player list: everyone who speaks after a seek is someone the
roster already holds.
Set replay.announce-seeks to false for a silent jump, which keeps the roster
correct without the messages.
Text replacement
Lines can be rewritten as they are replayed, which is useful for scrubbing a
phrase, a slur, a link, or a name before anyone sees it. The same feature is
sometimes called filtering.
Run /fauxplayers replay to see the full list of sub-commands, which is built
from the same list that drives completion:
Use /fauxplayers replay <enable|disable|file|speed|loop|restart|seek|skip|chat
|discord-chat|deaths|events|maximum-gap-seconds|maximum-players|replace|unreplace
|replacements> ...
replay:
replacements:
- from: "annoying phrase"
to: "replacement"
- from: "discord.gg/abcdef"
to: ""
Each from is matched as literal text, case sensitively, and every occurrence
is replaced. An empty to deletes the match.
The rules are applied to the whole line before it is replayed, to in-game chat,
Discord chat, death messages, and other server output alike. Matching happens
after the line is classified, so a rewrite can never turn a join into a chat
message or hide a death.
In game:
/fauxplayers replay replace <from>=<to> adds one. The first = splits it, so
spaces work on both sides.
/fauxplayers replay unreplace <from> removes one.
/fauxplayers replay replacements lists them.
Run /fauxplayers replay restart after a change so the loaded lines are rebuilt.
Reading the status
/fauxplayers replay reports enough to tell a waiting replay from a stalled one:
Replay » enabled=true | file=legacy.csv | speed=1.0 | loop=true
Lines: 28/547884 | players: 3 | finished: false
Clock: 2h 14m of 373d 4h 0m | next line in 12s | ticks driven: 8420
- Lines counts the lines already replayed, out of the lines in the file. It
starts at 0 and the first line is dispatched on the first tick after enabling.
- Clock is how far into the original timeline the replay has reached, out of
the whole timeline.
- next line in is the wait until the next line is due. A large figure is the
replay playing a quiet stretch, not a problem. Use
skip to pass it.
- ticks driven counts how often the game loop has driven the replay. It must
keep climbing. A figure that never changes means the loop is not running, which
is worth reporting, because a replay that is waiting still counts ticks.
Speed and gaps
The replay is real-time by default. replay.speed compresses the clock: 10
replays ten seconds of history per real second.
A long quiet period can make a replay wait for a long time. By default,
replay.maximum-gap-seconds is 0, which disables the cap and preserves the
CSV timestamps exactly. Set it to a positive number to cap the wait before any
one line; for example, 30 turns a two day outage into a thirty second pause.
The capped waits add up, so the cap only costs one pause per quiet period. Lines
that were a second apart still replay a second apart, even straight after a
capped outage. A low value compresses long waits, and a high value keeps more of
the silence. This also affects quiet and empty stretches: the wait before a line
while nobody is online is capped the same way.
At 1.0 with the gap cap disabled, replay time matches the CSV timeline. The
sample export covers 373 days; at 100 it takes about 3.7 days, and at 1000
about 9 hours.
The replay emits at most 200 lines per tick, about 4000 per second, so a very
high speed settles at that rate instead of going faster.
Ordering caveats
replay.chat replays in-game chat, replay.discord-chat replays Discord chat,
replay.deaths replays death messages, and replay.events replays the rest of
the server output. Turn one off to keep a quieter channel.
replay.maximum-players limits how many replayed players can be listed at once.
Players above the limit still chat, but do not get a player-list entry.
- The export is parsed once on startup. Change
replay.chat,
replay.discord-chat, replay.deaths, replay.events, or
replay.maximum-gap-seconds and then run /fauxplayers replay restart.
- A relay line labelled
Server, meaning the server speaking about itself,
replays as chat from Server. That label is what the export calls it, and it is
not a real account.
- Some servers forward their own chat to Discord and then take it back again. The
echo is a second line with the same words, so it replays twice. The same
happens to a death that both accounts carry.
- A replay covering people who are on the server now leaves their lines out. See
the real players section above.
A Discord handle and the in-game name can differ. Replay keeps each line under
the name the export used for it.
Troubleshooting
Fake names do not appear
Check status.enabled and tab.enabled.
Check the related include-* settings.
Check the server log for packet or TAB errors.
TAB shows one online player
Check that TAB is installed and enabled.
Check that tab.enabled is true.
The server's real online count remains unchanged.
The Ping: N score does not appear
Enable TAB's player-list objective.
Install the rebuilt JAR.
Restart the server.
Relay data is stale
Run /fauxplayers status.
Check the cache age and last error.
Run /fauxplayers refresh.
Check the host, port, URL, timeout, and relay source.
The replay is enabled but nothing happens
Run /fauxplayers replay and read the figures.
Loaded: (none) means the file has not been read yet, or the path is wrong.
A large export takes a few seconds to parse before the first line replays.
next line in counting down to a large figure means the replay is playing a
quiet stretch of the history. That is the file being followed faithfully. Use
/fauxplayers replay skip <lines> to pass it, or lower
replay.maximum-gap-seconds.
ticks driven frozen means the game loop is not driving the replay. The server
log will hold a warning naming the cause, because a failure in the loop is
reported instead of silently stopping it.
Replay does not start
Run /fauxplayers replay.
Check replay.enabled and the resolved file path.
Check the last error line and the server log.
Run /fauxplayers replay restart after changing the file or the text
replacements, which are also called filters.
The first load parses the whole file in the background.
A large export takes a few seconds before the first line is replayed.
A replayed player has the default head
A head is only real when the name resolves to a Mojang account. FauxPlayers keeps
asking: a name that failed is retried every twenty seconds, and a head already sent
is rebuilt as soon as the real skin arrives, so nothing stays wrong for the rest of
the session.
Mojang lookups run over the plugin's own HTTP client with a generous timeout.
A slow reply is never treated as "no such account"; only an answer of 404 or 204
is, and even then the name is retried, just less often.
Three things can stop a head from being real.
- The account was renamed or deleted since the export was written. Mojang only
resolves current names, so a name from an old log can answer 404 with no way to
recover the skin. Those are still retried, but only every ten minutes, because
asking more often cannot help. This is permanent for that name.
- The lookups were throttled. Mojang answers a burst of name lookups with HTTP
429. FauxPlayers spaces its lookups out and never remembers a failure, so a
throttled name is retried and the head fills in shortly afterwards.
- Mojang was slow or unreachable. The lookup is retried and the head is
rebuilt when it succeeds.
A warning in the log names the reason the first time it happens.
License
FauxPlayers is released under the GNU General Public License, version 3.
评论 0
登录后参与评分
还没有评论,来抢沙发吧