LuckPerms 各种信息堆 - Minecraft(我的世界)中文论坛

## 简介
## Intro
LuckPerms API 允许你更改大量的插件内部编程，并且能够轻松地将 LuckPerms 深度集成到你的插件和系统里。
LuckPerms API allows you to change a huge amount of the plugins internals programmatically, and easily integrate LuckPerms deeply into your existing plugins and systems.

大多数的其他的权限要么没有 API，要么有很差的 API，或者是有很差的文档的 API，而且里面的方法和类可能随机在不同版本里消失或是移动。Vault 项目就是一个很好的接口，并且是将大量插件一次性集成的很好的方法，可惜他的功能实在是太少了。
Most other permissions plugins either don't have APIs, have bad APIs, or have APIs with poor documentation and methods and classes that disappear or move randomly between versions. The Vault project is a great interface and a great way to integrate with lots of plugins at once, but its functionality is very limited.

LuckPerms 遵循 Semantic 版本控制，也就是意味着一个不向后兼容的新的 API 出现时，主版本会增加这个 API，你可以放心你的集成不会因为版本的不同而崩溃，主要的版本是保持不变的。
LuckPerms follows Semantic Versioning, meaning whenever a non-backwards compatible API change is made, the major version will increment. You can rest assured knowing your integration will not break between versions, providing the major version remains the same.

## 如何在项目里使用 API
## How to use the API in your project
LuckPerms 的 API 包是 https://github.com/lucko/LuckPer ... /me/lucko/luckperms
The API package in LuckPerms is [`me.lucko.luckperms.api`](https://github.com/lucko/LuckPer ... /me/lucko/luckperms).

我的 Nexus 服务器可以在这里找到 https://nexus.lucko.me/](https://nexus.lucko.me/，你在你的构建脚本里需要的仓库在 https://repo.lucko.me/](https://repo.lucko.me/
My Nexus Server can be found at [https://nexus.lucko.me/](https://nexus.lucko.me/). The repository you need for your build scripts is [https://repo.lucko.me/](https://repo.lucko.me/).

#### 其他有用的链接
#### Other useful links
* [JavaDocs](https://luckperms.lucko.me/javadocs/)
* [CI Server](https://ci.lucko.me/job/LuckPerms/)

### Maven
````xml
<repositories>
<repository>
      <id>luck-repo</id>
      <url>https://repo.lucko.me/</url>
</repository>
</repositories>

<dependencies>
<dependency>
      <groupId>me.lucko.luckperms</groupId>
      <artifactId>luckperms-api</artifactId>
      <version>3.2</version>
      <scope>provided</scope>
</dependency>
</dependencies>
````

### Gradle
```gradle
repositories {
maven {
      name "luck-repo"
      url "https://repo.lucko.me/"
}
}

dependencies {
compile ("me.lucko.luckperms:luckperms-api:3.2")
}
```

## 使用指南
## Usage Instructions
使用 API，你需要获得 LuckPermsApi 接口的实例，这可以通过几个方法完成。
To use the API, you need to obtain an instance of the `LuckPermsApi` interface. This can be done in a number of ways.

```java
// 所有平台 (抛出 IllegalStateException 如果 API 没有被加载)
final LuckPermsApi api = LuckPerms.getApi();

// 或者可选的
Optional<LuckPermsApi> provider = LuckPerms.getApiSafe();
if (provider.isPresent()) {
final LuckPermsApi api = provider.get();
}

// Bukkit/Spigot
ServicesManager manager = Bukkit.getServicesManager();
if (manager.isProvidedFor(LuckPermsApi.class)) {
final LuckPermsApi api = manager.getRegistration(LuckPermsApi.class).getProvider();
}

// Sponge
Optional<LuckPermsApi> provider = Sponge.getServiceManager().provide(LuckPermsApi.class);
if (provider.isPresent()) {
final LuckPermsApi api = provider.get();
}
```

### 线程安全的警告
### A warning about thread safety
所有 LuckPerms 内部，包括 API 都是线程安全的，你可以在异步线程任意调用 API 而不用担心发生错误。
All LuckPerms internals are thread-safe, including the API. You can call API methods from async threads without incurring issues.

但是，请注意一些操作，（尤其是存储类）是阻塞的。[CompletableFuture](https://docs.oracle.com/javase/8 ... pletableFuture.html) 就是用于这种情况：防止由于较差的处理导致的增加的错误，当出现 IO 时主线程等待处理完成。注意在添加 Callback 时指定正确的处理器。
However, please be aware that some operations, (especially in the Storage class) are blocking. [CompletableFuture](https://docs.oracle.com/javase/8 ... pletableFuture.html)s are used in these situations to prevent accidental issues whereby through poor handling, the main server thread waits for I/O to execute. Care should be taken to specify the correct executor when adding callbacks to these futures.

### 我想将 LuckPerms 作为依赖项
### I want to depend on LuckPerms
在 Bukkit/Bungee，你需要在你的 plugin.yml 添加以下信息
On Bukkit/Bungee, you need to add the following to your plugins `plugin.yml`.
```yml
depend: [LuckPerms]
```

在 Sponge, 在你的插件声明添加这些。
```java
@Plugin(
      id = "myplugin",
      dependencies = {
            @Dependency(id = "luckperms")
      }
)
public class MyPlugin {
...
}
```

### 事件
### Events
LuckPerms 有一个完整的读写API，也有一个事件监听系统。由于插件的多平台的原因，我们使用了内部的事件系统，而不是每个平台已经使用的事件系统（举个例子，Bukkit Event API）。这意味着简单的注册你的平台的监听器将不会生效。
LuckPerms exposes a full read/write API, as well as an event listening system. Due to the multi-platform nature of the project, an internal Event system is used, as opposed to the systems already in place on each platform. (the Bukkit Event API, for example). This means that simply registering your listener with the platform will not work.

所有的事件都是异步触发的。这意味着不应该在监听器里交互或者调用任何不是线程安全的方法。
All events are **fired asynchronously**. This means you should not interact with or call any non-thread safe method from within listeners.

值得注意的是，大多数的 Bukkit/Sponge 都不是线程安全的，并且只应该使用主服务器线程来交互。你应该使用调度器来访问 LuckPerms 的监听器。
It is important to note that most of Bukkit/Sponge are **not** thread safe, and should only be interacted with using the main server thread. You should use the scheduler if you need to access these methods fron LuckPerms listeners.

### 我怎样才能监听一个事件
### How do I listen to an event
所有的事件接口都可以在 [me.lucko.luckperms.api.event](https://github.com/lucko/LuckPer ... luckperms/api/event) 包里找到，它们都继承了 [LuckPermsEvent](https://github.com/lucko/LuckPer ... LuckPermsEvent.java) 类。
All event interfaces can be found in the [me.lucko.luckperms.api.event](https://github.com/lucko/LuckPer ... luckperms/api/event) package. They all extend [`LuckPermsEvent`](https://github.com/lucko/LuckPer ... LuckPermsEvent.java).

监听事件应该获得 [EventBus](https://github.com/lucko/LuckPer ... event/EventBus.java) 实例，使用 [LuckPermsApi#getEventBus](https://github.com/lucko/LuckPer ... ckPermsApi.java#L68)即可。
To listen to events, you need to obtain the [`EventBus`](https://github.com/lucko/LuckPer ... event/EventBus.java) instance, using [`LuckPermsApi#getEventBus`](https://github.com/lucko/LuckPer ... ckPermsApi.java#L68).

为你的监听器创建另一个类常常是个好想法，这是一个你可以用来参考的类。
It's usually a good idea to create a separate class for your listeners. Here's a short example class you can reference.

```java
package me.lucko.test;

import me.lucko.luckperms.api.event.EventBus;
import me.lucko.luckperms.api.event.log.LogPublishEvent;
import me.lucko.luckperms.api.event.user.UserLoadEvent;
import me.lucko.luckperms.api.event.user.track.UserPromoteEvent;

public class TestListener {
private final MyPlugin plugin;

public TestListener(MyPlugin plugin, LuckPermsApi api) {
      this.plugin = plugin;

      EventBus eventBus = api.getEventBus();

      // use a lambda
      eventBus.subscribe(LogPublishEvent.class, e -> e.getCancellationState().set(true));
      eventBus.subscribe(UserLoadEvent.class, e -> {
         System.out.println("User " + e.getUser().getName() + " was loaded!");
         if (e.getUser().hasPermission("some.perm", true)) {
            // Do something
         }
      });

      // use a method reference
      eventBus.subscribe(UserPromoteEvent.class, this::onUserPromote);
}

private void onUserPromote(UserPromoteEvent event) {
      Bukkit.getScheduler().runTask(plugin, () -> {
         Bukkit.broadcastMessage(event.getUser().getName() + " was promoted to" + event.getGroupTo().get() + "!");

         Player player = Bukkit.getPlayer(event.getUser().getUuid());
         if (player != null) {
            player.sendMessage("Congrats!");
         }
      });
}

}
```

[EventBus#subscribe](https://github.com/lucko/LuckPer ... t/EventBus.java#L43) 返回一个 [EventHander](https://github.com/lucko/LuckPer ... t/EventHandler.java) 实例，可以用来在插件停止的时候取消注册监听器。
[`EventBus#subscribe`](https://github.com/lucko/LuckPer ... t/EventBus.java#L43) returns an [`EventHander`](https://github.com/lucko/LuckPer ... t/EventHandler.java) instance, which can be used to unregister the listener when your plugin disables.

## 示例用法
## Example Usage
下面就是一些简短的实例，使用了一些基本的 API 功能。
Below are some short examples which illustrate some basic API functions.

### 获得玩家的组
### Finding a players group
如果你只是想找到一个玩家的组，我非常建议你使用以下的方法（你甚至不需要使用 API）。
If you just want to find out which group a player is in, I **highly** recommend the following method. (you don't even need to use the API!)

```java
public static String getPlayerGroup(Player player, List<String> possibleGroups) {
for (String group : possibleGroups) {
      if (player.hasPermission("group." + group)) {
         return group;
      }
}
return null;
}
```
记住将你的组排列为优先级的顺序（比如组长在前，成员在后）。
Remember to order your group list in order of priority. e.g. Owner first, member last.

### 为一个玩家添加权限
### Adding a permission to a user
```java
LuckPermsApi api = null; // See above for how to get the API instance.

Optional<User> user = api.getUserSafe(uuid);
if (!user.isPresent()) {
return false; // The user isn't loaded in memory.
}

// Build the permission node we want to set
Node node = api.getNodeFactory().newBuilder(permission).setValue(true).build();

// Set the permission, and return true if the user didn't already have it set.
try {
user.get().setPermission(node);

// Now we need to save the user back to the storage
api.getStorage().saveUser(u);

return true;
} catch (ObjectAlreadyHasException e) {
return false;
}
```

### 为（可能的）离线玩家添加权限
### Adding a permission to a (potentially) offline user
CompletionStage API 可以用来轻松交互插件的存储，查看[这里](https://docs.oracle.com/javase/8 ... ompletionStage.html) 和 [这里](https://docs.oracle.com/javase/8 ... pletableFuture.html) 来查看这两个类的详细信息。
The CompletionStage API can be used to easily interact with the plugins Storage backing. See [here](https://docs.oracle.com/javase/8 ... ompletionStage.html) and [here](https://docs.oracle.com/javase/8 ... pletableFuture.html) for more details about these classes.

```java
LuckPermsApi api = null; // See above for how to get the API instance.

// load the user in from storage. we can specify "null" for their username,
// since it's unknown to us.
api.getStorage().loadUser(uuid, "null").thenComposeAsync(success -> {
// loading the user failed, return straight away
if (!success) {
      return CompletableFuture.completedFuture(false);
}

// get the user instance, they're now loaded in memory.
User user = api.getUser(uuid);

// Build the permission node we want to set
Node node = api.getNodeFactory().newBuilder(permission).setValue(true).build();

// Set the permission, and return true if the user didn't already have it set.
try {
      user.setPermission(node);

      // now we've set the permission, but still need to save the user data
      // back to the storage.

      // first save the user
      return api.getStorage().saveUser(user)
            .thenCompose(b -> {
                  // then cleanup their user instance so we don't create
                  // a memory leak.
                  api.cleanupUser(user);
                  return CompletableFuture.completedFuture(b);
            });

} catch (ObjectAlreadyHasException e) {
      return CompletableFuture.completedFuture(false);
}

}, api.getStorage().getAsyncExecutor());
```

### 获得玩家的前缀
### Getting a players
LuckPerms 有一个（复杂的）缓存系统，用于非常快速的权限/信息查询。这些类都在 API 里，并且可以在可能的地方使用。
LuckPerms has a (somewhat complex) caching system which is used for super fast permission / meta lookups. These classes are exposed in the API, and should be used where possible.

```java
LuckPermsApi api = null; // See above for how to get the API instance.

// Get the user, or null if they're not loaded.
User user = api.getUserSafe(uuid).orElse(null);
if (user == null) {
return Optional.empty(); // The user isn't loaded. :(
}

// Now get the users "Contexts". This is basically just data about the players current state.
// Don't worry about it too much, just know we need it to get their cached data.
Contexts contexts = api.getContextForUser(user).orElse(null);
if (contexts == null) {
return Optional.empty();
}

// Ah, now we're making progress. We can use the Contexts to get the users "MetaData". This is their cached meta data.
MetaData metaData = user.getCachedData().getMetaData(contexts);

// MetaData#getPrefix returns null if they have no prefix.
return metaData.getPrefix();
```

### 获得玩家请求的权限
### Getting a players applied permissions
我们也可以使用这个缓存系统来获得一个包含用户权限的 Map 实例，包含了基础的权限查询。
We can also use this caching system to get a Map containing the users permissions. This map contains the data which backs their permission lookups.
```java
// All retrieved in the same way as shown above.
User user;
Contexts contexts;

PermissionData permissionData = user.getCachedData().getPermissionData(contexts);
Map<String, Boolean> data = permissionData.getImmutableBacking();
```

### 寻找权限
### Searching for a permission
你可以使用 Java 8 的流轻松过滤并返回一个用户请求的权限
You can use Java 8 streams to easily filter and return permissions applied to a user.
```java
public boolean hasPermissionStartingWith(UUID uuid, String startingWith) {
// Get the user, if they're online.
Optional<User> user = api.getUserSafe(uuid);

// If they're online, perform the check, otherwise, return false.
return user.map(u -> u.getPermissions().stream()
         .filter(Node::getValue)
         .filter(Node::isPermanent)
         .filter(n -> !n.isServerSpecific())
         .filter(n -> !n.isWorldSpecific())
         .anyMatch(n -> n.getPermission().startsWith(startingWith))
).orElse(false);
}
```

### 创建新的组并分配权限
### Creating a new group and assigning a permission
这个方法不是阻塞的，所以可以安全的在主线程调用，一旦操作完成，回调会异步运行。
This method is not blocking, so can be safely called on the main server thread. The callback will be ran async too, once the operation has finished.
```java
api.getStorage().createAndLoadGroup("my-new-group").thenAcceptAsync(success -> {
if (!success) {
      return;
}

Group group = api.getGroup("my-new-group");
if (group == null) {
      return;
}

Node permission = api.buildNode("test.permission").build();

try {
      group.setPermission(permission);
} catch (ObjectAlreadyHasException ignored) {}

// Now save the group back to storage
api.getStorage().saveGroup(group);
}, api.getStorage().getAsyncExecutor());
```

## 版本控制
## Versioning
在 2.0 版本里，LuckPerms 遵循了 Semantic 版本控制。
As of version 2.0, LuckPerms roughly follows the standards set out in Semantic Versioning.

唯一不同的是 patch 号不包含在任何地方，除了 pom，并且每次构建都会计算，基于上次提交后的提交数量。（每个新的小版本都会创建新的标签）
The only difference is that the patch number is not included anywhere within the pom, and is calculated each build, based upon how may commits have been made since the last tag. (A new tag is made every minor version)

这意味着 API 版本不再有 patch 号（在 patch 里没有 API 的变化），API 版本会是 x.y，每个不同的 LuckPerms 构建都会遵循 x.y.z。
This means that API versions do not have a patch number (as no API changes are made in patches). API versions will be x.y, and each individual build of LuckPerms will follow x.y.z.

### 变更日志
### Changelog
* 版本 2.x 保持了几个月的稳定，没有任何向后不兼容的变更，但是在之后的版本里很多的方法变为弃用状态，并且事件 API 的确应该重写一遍。
* Version 2.x remained stable for a number of months, without any backwards incompatible changes. However, a number of methods became deprecated in the later versions, and the event API really needed a rewrite.
* 版本 3.x 包含了以下的向后不兼容的变化。
* Version 3.x introduced the following backwards incompatible changes.
https://gist.github.com/lucko/fdf6ae4b2d9e466d8103dd9c68e5db9e

# 常见问题
# Frequently Asked Questions
这些是我经常被问到的问题，我很高兴你在直接问我之前看了这些问题。
These are some of the questions I get asked quite frequently. I'd appreciate it if you check to see if your question has already been answered here before asking me directly.

### 我在用 EssentialsChat 然后它不工作了
### I'm using EssentialsChat and it's not working
请确保你在使用最新版的 [EssentialsX](https://ci.drtshock.net/job/essentialsx/) 并且你安装了 [Vault](https://dev.bukkit.org/bukkit-plugins/vault/)。EssentialsX 的 X 是很重要的，老的版本不会工作。
Please make sure you are using the latest version of [EssentialsX](https://ci.drtshock.net/job/essentialsx/) and you have [Vault](https://dev.bukkit.org/bukkit-plugins/vault/) installed on your server. The "**X**" part of Essentials**X** is important - the older versions of Essentials do not work.

### 我在哪里安装 LuckPerms 呢？
### Where do I install LuckPerms?
如果你在运行很多的服务器，你应该将 LuckPerms 放入每个服务器的 plugins 文件夹。
If you run a network of servers, you should install LuckPerms into the plugin folder of every server you want to use LuckPerms on.
如果你想使用 BungeeCord 来应用权限，你需要将 LuckPermsBungee.jar 放入 BungeeCord 插件文件夹。
If you also want to use LuckPerms to apply permissions on your BungeeCord proxy, you should place LuckPermsBungee.jar into your BungeeCord plugins folder.
如果你选择只在 BungeeCord 安装 LuckPerms，他将不会影响任何 Spigot/Sponge 服务器的权限检查，如果你想要使用 LuckPerms，你必须将 LuckPerms 安装在这些服务器。
If you choose to only install LuckPerms on your BungeeCord proxy, it will have no impact on any permission checks performed by plugins on any backend Spigot/Sponge servers. If you want that functionality, you need to install LuckPerms on those servers too.

### 我可以只在 BungeeCord 安装 LuckPerms 吗？
### Can I just install LuckPerms on BungeeCord?
在 BungeeCord 上的权限系统是完全独立于 Spigot/Sponge 服务器的。
The permissions system used on BungeeCord is completely separate from the systems used on the backend Spigot/Sponge server.
如果你想让 Spigot/Sponge 的权限检查被 LuckPerms 处理的话，在每个 Spigot/Sponge 服务器都安装 LuckPerms。
If you want the permission checks performed by Spigot/Sponge plugins to be handled by LuckPerms, install LuckPerms on your Spigot/Sponge server.
如果你想让 BungeeCord 服务器的权限检查被 LuckPerms 处理，在 BungeeCord 服务器安装 LuckPerms。
If you want the permission checks performed by BungeeCord plugins to be handled by LuckPerms, install LuckPerms on your proxy.
你可以只在 BungeeCord 安装 LuckPerms，但是 Spigot/Sponge 服务器的权限检查将不会被 LuckPerms 处理。
You **can** just install it on the proxy, but any checks which are performed by Spigot/Sponge plugins will not be handled by LuckPerms.

### 我应该怎样在多个服务器中同步权限呢？
### How do I get permissions to sync across multiple servers
将每个 LuckPerms 连接到同一个 MySQL/MongoDB 服务器，你可以使用 /luckperms sync 来从数据库获得最后的权限更新。你也可以 [建立一个通讯服务](https://github.com/lucko/LuckPer ... #messaging-services) 来立刻在你的服务器之间同步更改。
Connect each LuckPerms installation to the same MySQL/MongoDB server. You can use `/luckperms sync` to pull the latest changes from the database. You can also [setup a Messaging Service](https://github.com/lucko/LuckPer ... #messaging-services) to have your changes sync instantly between servers.

### LuckPerms 不能连接到我的 Redis 服务器
### LuckPerms cannot connect to my Redis server
检查以下是否正常：
Check that the following is correct:

* 你正阿紫使用正确的地址和端口
* You are using the correct address and port
* 你的密码是正确的
* Your password is correct
* 没有防火墙规则阻拦了连接
* There are no firewall rules blocking the connection
* Redis 服务器正在运行
* The Redis server is actually running

### LuckPerms 不能连接到我的 MySQL 服务器
### LuckPerms cannot connect to my MySQL server
检查以下是否正常：
Check that the following is correct:

* 你正在使用正确的地址和端口
* You are using the correct address and port
* 你使用了正确的用户名 / 密码
* You are using the correct username / password
* 数据库存在并且用户可以访问
* That the database exists and is accessible by the user
* 该服务器在线并且接受连接
* That the server is online & accepting connections
* 没有防火墙规则阻拦了连接
* There are no firewall rules blocking the connection
* MySQL 正确绑定了端口，并且安装 LuckPerms 的服务器可以访问
* MySQL is bound to the correct port, and is accessible from the server where LuckPerms is installed
* 检查 MySQL 的连接限制没有超过，默认 LuckPerms 会使用 10 个连接，如果你有过多的插件连接了同一个服务器，你需要增加这个限制。
* Check that your MySQL max connections limit is not being exceeded. By default, LuckPerms will use 10 connections per server. If you have lots of plugins connecting to the same server, you will need to increase this limit.

如果你得到了 `Communications link failure` 的错误，或者由于超时导致的错误，那么上面的有一条是不正常的。
If you are getting `Communications link failure` errors, or errors relating to a timeout, then something from the list above is incorrect.

给玩家 LuckPerms 表的权限，使用
To give the user access to the LuckPerms tables, execute:
```sql
GRANT ALL PRIVILEGES ON [databasename].* TO '[username]'@'[ipaddress]';
```
记得替换 [ ] 里的东西。

比如：
```sql
GRANT ALL PRIVILEGES ON luckperms.* TO 'luck'@'%';
```

接着当你完成这个更改后，使用
```sql
FLUSH PRIVILEGES;
```

LuckPerms 有内置的支持其他的权限插件轻松迁移到 LuckPerms 的功能。
LuckPerms has built in support to allow easy migration of permissions data from existing permissions plugins to LuckPerms.

## 开始之前
## Before we get started
需要注意的是这个系统还不是那么的完美，在绝大多数情况下，它在转变数据时相当不错，但是不是所有的数据都是相同的，并且有时我可能没有考虑这么多。
It should be noted that this system is not perfect. It will do a pretty decent job at converting all of your existing data, and works perfectly in *most cases*. However, not all data is the same, and there are sometimes things I haven't accounted for.

LuckPerms 有和其他权限插件相同的地方，但是有些部分从根本上不同，有些迁移运用了一些技巧。
LuckPerms has some similarities with other permission plugins, however, some parts are fundamentally different, and therefore sometimes automatic migration is tricky.

另外，让插件迁移你的所有的数据意味着你没有机会学习任何一个 LuckPerms 命令，这可能会是一个麻烦的地方，如果你是从 PermissionsEx 或者 GroupManager 迁移来的数据，你应该看看 [GM PEX 的等同命令](https://github.com/lucko/LuckPer ... Command-Equivalents)
Additionally, letting the plugin migrate all of your data for you means you will not have a chance to learn any of the LuckPerms commands. This may become an issue later on. If you're migrating from PermissionsEx or GroupManager, you might [find this page useful](https://github.com/lucko/LuckPer ... Command-Equivalents).

如果你使用了老版本的权限插件，或者你根本不喜欢的，现在可能是一个机会来重新构建清理，顺便学习 LuckPerms 的命令！
If you have an old permissions setup, or a setup you're not completely happy with, now might be a great time to have a restructure and cleanup, and a chance to learn LuckPerms commands in the process!

不？！就喜欢你现在的权限插件？让我们来迁移。
Nope?! Happy with what you have? Let's migrate.

## 目前支持的插件
## Currently supported plugins
| Bukkit / Spigot    | BungeeCord          | Sponge             |
|-----------------------|-----------------------|-----------------------|
| GroupManager       | BungeePerms          | PermissionsEx       |
| PermissionsEx       |                      | PermissionManager    |
| zPermissions       |                      |                      |
| PowerfulPerms       |                      |                      |
| bPermissions       |                      |                      |

# 如何
# How to
迁移的处理很简单，但是每个平台可能有不同。
The migration process is fairly simple, however it varies slightly for each platform.

1. 将 LuckPerms jar 文件放入你的服务器文件夹。
1. Place the LuckPerms jar file in your servers plugin folder. ([How to?](https://github.com/lucko/LuckPerms/wiki/Setup))
2. 保证两个权限插件的文件夹在同一个文件夹里（现在还不要卸载）
2. Ensure that the jar of the plugin you are migrating from is **also** in the plugins folder. (don't uninstall it just yet!)
3. 开启服务器，你可以在活跃的服务器来进行这个操作，但是我建议在没有人的服务器上进行。
3. Start your server up. You can technically carry out the process on a live production server, however I advise that if possible, you do it on a server with no players.

**运行一下命令: `lp migration <插件名>`**
**Run the following command: `/lp migration <plugin name>`**

有些插件需要你填写额外的选项/标签，如果需要，你会在迁移之前被通知。
Some plugins also require you to specify extra options/flags. If any are needed, you will be notified in chat before the migration begins.

接着只需要让 LuckPerms 处理剩下的事了！你将会被提示迁移进度，完成时也会被提示。
Then, just let LuckPerms handle the rest! You will be notified of the migration progress, and then notified again once it has finished.

当处理完成，停止服务器，移除其他权限插件的 jar，再次开启你的服务器。
When the process has finished, stop the server, remove the other jar file, and start your server again.

控制台的输出一定是冗长繁杂的，以 "(LP) LOG" 开头的命令都可以忽略，但是栈堆信息不应该忽略（一般表示出现了什么问题）。如果你的迁移输出含有栈堆信息，请反馈给我，更多的信息在这一个页面的底部。
The console output during the migration process is purposely verbose and spammy. Messages starting with "(LP) LOG" can be ignored, however stack traces shouldn't be (they usually mention some sort of exception). If your migration output contains stack traces, please report them to me. More info at the bottom of this page.

## PowerfulPerms
处理 PowerfulPerms 的过程更加复杂。
The process for PowerfulPerms is more complicated.

玩家的信息只有在加入服务器时才被加载，插件 API 没有方法一次性获得所有的玩家的数据。
Users are only loaded into the plugin when they join the server, and the plugins API does not expose a way to get all players from its backend.

这意味着我们在导入数据时，我们必须得查询 PowerfulPerms MySQL 表来获得所有玩家的信息。
This means that during the import process, we have to query the PowerfulPerms MySQL tables to get a list of all users.

命令使用将会不同。
The command usage is therefore different.

`/luckperms migration powerfulperms [address] [database] [username] [password] [db table]`

解释：
Where:
* address = MySQL 服务器的 IP 地址，比如 127.0.0.1:3306
* address = the address and port of your MySQL server e.g. 127.0.0.1:3306
* database = PowerfulPerms 插件使用的数据库的名称
* database = the name of the database where your PowerfulPerms data is stored
* username = SQL 服务器登入需要的用户名
* username = the username to login to the SQL server
* password = SQL 服务器登入需要的密码
* password = the password to login to the SQL server
* db table = 存储玩家数据的表名（尽管我们只关注 UUID 列表）
* db table = the name of the table where player data is stored (although we're only concerned about a list of uuids).

默认的表名，据我所知，是 "players"，但是如果你添加了表名的前缀，你需要添加他们。
The default db table, as far as I know, is "players", however if you have an added table prefix, you will need to include that too.

比如如果我的表的前缀是 "pp_"，那么 db table = "pp_players"（不需要引号）
e.g. if my table prefix is "pp_", the db table should = "pp_players". (without the quotes)

比如: `/luckperms migration powerfulperms 127.0.0.1:3306 minecraft root passw0rd players`
For example: `/luckperms migration powerfulperms 127.0.0.1:3306 minecraft root passw0rd players`

# 错误
# Errors
如果这个命令不存在，请检查这个插件是否正确加载。
If it seems that the command does not exist, check your server's startup log to check if the plugin you are importing from loaded correctly.

如果处理没有完成，并且打印了错误消息，请在 GitHub 提交 issue 或者 [在这里联系我](https://github.com/lucko/LuckPerms/wiki#cant-find-something)，我将尽力尽可能快的回复你。
If the process doesn't complete and prints an error message, please submit an Issue on GitHub or [contact me here](https://github.com/lucko/LuckPerms/wiki#cant-find-something). I'll try to reply to you ASAP.

## 如何
## How to
切换存储是很简单的。
Switching datastores is easy.

1. 第一，运行 `/luckperms export <file>`
1. Firstly, run `/luckperms export <file>`
2. 接着，完全停止你的服务器
2. Then, stop your server completely.
3. 编辑你的配置文件，更改存储类型
3. Edit your config file and change the storage type.
4. 开启你的服务器，等待数据存储的初始化
4. Now, start your server again. Let the new datastore initialise.
5. 接着，使用 `/luckperms import <file>`
5. Then, run `/luckperms import <file>`
6. 所有的数据已经迁移到新的数据存储中了
6. All of your data should have been moved to the new datastore.

<file> 是你想用来存储/加载的文件的名称，文件位于 LuckPerms 的数据文件夹里。你可以任意命名，只要在 import 命令中正确填写。
\<file\> is the name of the file which you want to save to/load from. The file is located in the LuckPerms data folder. You can name it whatever you like in the import command.

## 备份
## Backups
你可以使用这个特性来备份所有你的 LuckPerms 的数据，只需要运行 export 命令，将文件保存到一个安全的地方。
You can also use this feature to backup all of your LuckPerms data. Just run the export command, and save the file output in a safe place.

## 这是怎么工作的？
## How does it work?
export 命令将所有的数据转换为一串命令，处理后将会重建你的安装，import 命令只是将每个命令运行一遍，这意味着你可以只导出/导入一小部分数据，你删掉不需要的一部分就可以了。
The export command converts all of your data into a list of commands, than when executed, will recreate your existing setup. The import command just runs each command sequentially. This means that you can export/import small parts of your data, by deleting the parts you don't need.

我在 LuckPerms 里处理默认和默认组的方法可能是整个插件里最不受喜爱的特性了。最新我做了一些添加/调整，做了一些替代的特性，允许最大程度的控制像其他权限插件的方法，希望这会成为插件最好的方面，而不是最差的方面。
The way I handle defaults and default groups in LuckPerms is probably the most disliked feature in the whole plugin. Recently I've been adding some additional / alternative features to the plugin to allow a greater degree of control compared with what's seen in any of the other permission plugins out there, and hopefully making my approach people's favourite part of the plugin, not their least favourite.

# 从何开始
# Where to start
这是我的想法。
So, here's my thinking.

你的服务器的用户可以分为两种。
Users on your server are likely to be split into two types.

1. 基础玩家
1. The standard player.
2. 加入不同的组的玩家，或者有他们特别权限的玩家。
2. Players who have been added to a different group, or given their own special permissions.

你不希望浪费宝贵的硬盘空间来存储第一种玩家，你只希望存储你的职员，或者有特殊等级的玩家。平凡的"成员"就只是平凡，没有必要存储他们的信息。
You don't want to waste precious disk space storing data about Player Type #1. You only want to store data about your staff members, and people with special ranks. Regular "members" are just that, regular. There's no need to store any data about them.

下一个问题是如何确定一个用户是"平凡的"或不是，想象一下情景。
The next issue I face is how to decide if a user is "regular" or not. Imagine the following situation.

1. 默认的组设置为"默认"，当玩家加入，他们被设置为"默认"，并被保存。
1. The default group is set to "default". When players join, they're given "default", and then get saved.
2. 过了一会儿，你想将默认的组更改为"成员"。
2. A little while down the line, you decide you want to change the default group to "member".
3. 接着你的老的成员全部在"默认"组里，剩下的人都在"成员"，这不好。
3. You then have all of your old players in the "default" group, and everyone else in "member". Not good.

甚至我们没有"平凡"的用户，这个问题依然会出现。
Even if we don't save "regular" users, this issue can still happen.

1. 默认组设置为"默认"
1. The default group is set to "default".
2. 你想给 "Notch" 一个特殊的 "essentials.fly" 权限，Notch 的权限被保存，标记为"默认组"的成员，有特殊的飞行权限。
2. You want to give "Notch" a special "essentials.fly" permission. Notch's permissions are saved, indicating he's a member of the "default" group, and has the special fly permission.
3. 接着你编辑了默认的组，所有的"平凡的"成员全部进入了新的组，但是 Notch 还是默认组的。
3. You then edit the default group. All of your "regular" members get the new default group, but Notch still has default!

因为这个原因，我让默认的组不可配置，这让所有对我的事情都简单了 10 倍，这意味着我可以写有效率的存储系统，并且不用担心一些稀有的情况下服务器的管理员更改了默认组，但是，我知道这对一些人很反感。
For this reason, I made it so that the default group is **not** configurable. It makes things 10x easier for me. It means I can write efficient storage systems, with no chance of nasty race conditions occurring when a server admin decides to change the default group. However, I understand this is annoying for some people.

这对一些等级插件也有问题，如果你想要一个"主"组，并且分离"升级"组，你需要多于一个的默认组。
There's also issues with rankup plugins. If you want a "main" group, and then separate "level" ranks, you need to be able to grant more than one group by default.

这里是你的选项。
Here are your options.

## 继续使用默认组，但是只是更改"显示名"
## Keep using the default group, but just modify the "display name"
我非常推荐这个做法，因为你继续使用默认组。
I strongly recommend for the reasons above that you keep using the default group.

如果你只是想简单的更改默认组的显示名，（比如在 Vault），我推荐你配置一个 `group-name-rewrite` 规则，通过添加这些到你的 `config.yml`/`luckperms.conf` 来实现。
If you want to simply change the visible name of the default group, (in Vault for example), I suggest you configure a `group-name-rewrite` rule, by adding the following to your `config.yml`/`luckperms.conf` file.

```yml
# Rewrites group names. The underlying name of the group does not change, just the output in commands / placeholders / Vault.
group-name-rewrite:
  default: Member
```

你也可以使用这个：https://github.com/lucko/LuckPerms/wiki/Primary-Groups
You can also use this approach: https://github.com/lucko/LuckPerms/wiki/Primary-Groups

## 配置继承
## Configure inheritance
这个选项意味着所有的用户都还在"默认"的组里，但是这个默认组作为父组，这样他就可以将配置继承给不同的组。
This option would mean that all users are still in the "default" group. However, a parent group is configured for default, so it can inherit permissions from a group with a different name.

```
/luckperms creategroup member
/luckperms group default parents add member
```

## 配置默认分配
## Configure default assignments
如果你有更多的特殊需要，你可以使用这个选项，但是，这将否定我们在这个页面的第一节讨论的存储空间规划，所有的用户都会被存储，无论是"平凡的"成员还是不是。
If you have more specific needs, then you can use this option. However, be aware that it will negate the storage space optimisations discussed in the first section of this page. All users will be explicitly saved, whether they are a "regular" user or not.

##### 注意：查看 "Default Assignments" 章节
##### Note: see the "Default Assignments" section of the config for more detail on this.

接下来的规则将会创建一个不同的默认的组。
The following rule will configure a different default group.
```yml
default-assignments:
  my-defaults-rule:
if:
   has-true: <group.default>
take:
   - group.default
give:
   - group.member
set-primary-group: member
```

放入以后，每次玩家登入时，插件会检测这个玩家是不是"默认"组的成员，如果是，插件将会把玩家从"默认"组移除，将他们添加至"成员"组，将他们的主组也设置为"成员"组。
Simply put, every time a user logs in, the plugin will check if they are a member of the "default" group. If they are, it will remove them from "default", add them to "member", and set their primary group to "member".

这个系统非常强力，允许你配置按你自己的需求而定的默认组，记住你可以将玩家添加至不止一个的"默认"组。
This system is very powerful, and allows you to configure defaults to your exact needs. Remember you _could_ add users to more than one "default" group.

不同平台的 LuckPerms 的配置文件可以在这里找到。
The main configuration file for LuckPerms can be found at these locations.

| 平台       | 位置                                                                                                                   |
|---------------|-------------------------------------------------------------------------------------------------------------------------------|
| Bukkit/Spigot | [`/plugins/LuckPerms/config.yml`](https://github.com/lucko/LuckPer ... esources/config.yml)       |
| BungeeCord | [`/plugins/LuckPerms/config.yml`](https://github.com/lucko/LuckPer ... esources/config.yml)       |
| Sponge       | [`/config/luckperms/luckperms.conf`](https://github.com/lucko/LuckPer ... rces/luckperms.conf) |

请注意配置文件不能在有新配置的时候自动添加，如果文件中没有找到任何东西，我们将使用默认选项。
Links to the default file for each platform are above. Please note that the configuration does not automatically update when new options are added. The default options are used if nothing is found in the file.

## 索引
### 基础
* [`server`](#server)
* [`include-global`](#include-global)
* [`include-global-world`](#include-global-world)
* [`apply-global-groups`](#apply-global-groups)
* [`apply-global-world-groups`](#apply-global-world-groups)
* [`use-server-uuids`](#use-server-uuids)
* [`log-notify`](#log-notify)
* [`world-rewrite`](#world-rewrite)
* [`group-name-rewrite`](#group-name-rewrite)
* [`temporary-add-behaviour`](#temporary-add-behaviour)
* [`primary-group-calculation`](#primary-group-calculation)
### 权限计算
* [`apply-wildcards`](#apply-wildcards)
* [`apply-regex`](#apply-regex)
* [`apply-shorthand`](#apply-shorthand)
##### Bukkit
* [`apply-bukkit-child-permissions`](#apply-bukkit-child-permissions)
* [`apply-bukkit-default-permissions`](#apply-bukkit-default-permissions)
* [`apply-bukkit-attachment-permissions`](#apply-bukkit-attachment-permissions)
##### Bungee
* [`apply-bungee-config-permissions`](#apply-bungee-config-permissions)
##### Sponge
* [`apply-sponge-implicit-wildcards`](#apply-sponge-implicit-wildcards)
* [`apply-sponge-default-subjects`](#apply-sponge-default-subjects)
### 服务器管理员 / Vault (仅 Bukkit 版本)
* [`enable-ops`](#enable-ops)
* [`auto-op`](#auto-op)
* [`commands-allow-op`](#commands-allow-op)
* [`use-vault-server`](#use-vault-server)
* [`vault-server`](#vault-server)
* [`vault-include-global`](#vault-include-global)
* [`vault-ignore-world`](#vault-ignore-world)
* [`vault-debug`](#vault-debug)
### 存储
* [`storage-method`](#storage-method)
* [`watch-files`](#watch-files)
* [`split-storage`](#split-storage)
* [`data`](#data)
* [`pool-size`](#pool-size)
* [`table-prefix`](#table-prefix)
* [`sync-minutes`](#sync-minutes)
* [`messaging-service`](#messaging-service)
* [`auto-push-updates`](#auto-push-updates)
* [`redis`](#redis)

## 基础
___
### `server`
服务器的名称，用于制定服务器的权限。
The name of the server, used for server specific permissions.
如果设置为 "global" 这个设置将会被忽略，更多关于服务器指定的权限可以在[这里](https://github.com/lucko/LuckPerms/wiki/Advanced-Setup)找到。
If set to "global" this setting is ignored. More details about how server specific permissions are groups work can be found [here](https://github.com/lucko/LuckPerms/wiki/Advanced-Setup).

##### 示例
```yaml
server: global
```

___
### `include-global`
这个服务器的玩家是否应该应用他们的全局权限。（没有指定服务器的权限）
If players on this server should have their global permissions applied. (permissions that were not set with a specific server).
如果这个选项被设置为 false，只有指定在此服务器的权限才会被应用。如果上方的 "server" 选项设置为 global，请不要将其设置为 false。更多的有关服务器指定的权限可以在[这里](https://github.com/lucko/LuckPerms/wiki/Advanced-Setup)找到。
If this option is set to false, only permissions that were specifically set to apply on this server will apply. Do not set to false if the "server" option above is set to global. More details about how server specific permissions are groups work can be found [here](https://github.com/lucko/LuckPerms/wiki/Advanced-Setup).

##### 示例
```yaml
include-global: true
```

___
### `include-global-world`
与上方的选项相似，只是这个选项用于世界的设定。如果设置为 false，只有指定了世界的权限才会被应用至玩家。任何没有指定世界的权限都不会被应用。
Similar to the option above, except this works with worlds. If set to false, only permissions that are set in specific worlds will be given to users. Any permissions set without a specific world context will not be applied.

##### 示例
```yaml
include-global-world: true
```

___
### `apply-global-groups`
这个选项与 "include-global" 选项类似，但是此选项更改了组的继承设定。
This option operates in the same manner as "include-global", except changes the setting for group inheritance.
当计算玩家的权限时，插件将会给继承树设定范围，递归解析组成员关系。如果这个设置设置为 false，如果一个组没有被应用，那么它的父组都不会被计算，继承查询将会在此终止。
When calculating a players permissions, the plugin will scale the inheritance tree, resolving group memberships recursively. If this setting is set to false, and as a result, a group is not "applied", then none of that groups parents will be considered, and the inheritance lookup will stop at that point.
这意味着就算一个玩家没有在一个特定服务器直接继承一个组，如果这个组通过了一个没有指定服务器的组继承，这个组将不会被应用。
This means that even if a player indirectly inherits a group on a specific server, the group will not be applied if it is inherited through a non-server specific group.

举个例子，当设置为 false，使用以下设置：
For example, with this setting false, and the following setup:

```
User "Luck" inherits from group "admin" globally, and admin inherits from "default" on a specific server.
```

尽管 Luck 在指定服务器上继承了默认组，它将不会被应用，因为继承查询在 admin 停止。admin 的父组将不被考虑。
Even though Luck inherits default on the specific server, it will not be applied, because the inheritance lookup stops at admin. The parent groups of admin are therefore never even considered.

##### 示例
```yaml
apply-global-groups: true
```

___
### `apply-global-world-groups`
与上面的选项相似，但是这个选项用于世界的设定。如果设置为 false，只有指定了世界的组才会被分配，给用户解析。任何没有指定世界的组都不会被应用。
Similar to the option above, except this works with worlds. If set to false, only groups that are set in specific worlds will be assigned and resolved for users. Any groups set without a specific world context will not be applied.

##### 示例
```yaml
apply-global-world-groups: true
```

___
### `use-server-uuids`
如果使用服务器的UUID，或者根据之前的连接的用户名来查询，那么这个设定应该使用 true，除非你很确定你在做什么。
If UUIDs should be pulled from the server, or looked up by username based upon previous connections. This setting should be kept set to true, unless you're sure you know what you're doing.
一般的，当这个选项设置为 true 时，当玩家登入时，LuckPerms 将会使用服务器提供的用户名/UUID来标识玩家。这个在大多数的服务器都是适用的。
Normally, when this is set to true: when a player logs in, LuckPerms will use the username / uuid provided by the server to identify the player. This is fine for the majority of servers.
当设置为 false，LuckPerms 将会检查玩家是否曾经在服务器登录过，如果找到了一个玩家，那么之前映射的UUID将会被使用，否则将会回到默认的使用服务器的UUID的方法。
When set to false, LuckPerms will first check to see if someone has joined previously with the same username. If a player is found, then the previous UUID mapped to that username will be used. Otherwise, it will fallback to the standard method of retrieving uuids from the server.
在离线模式（破解版）的服务器，玩家的UUID基于他们的用户名创建。
On offline mode (cracked) servers, a players UUID is generated based upon their username.
**重要**
**Important:**
如果你在运行一个 BungeeCord 服务器，你必须开启 IP forward 设置，这将让服务器使用正确的UUID。
If you are running a BungeeCord proxy, you *must* have IP forwarding setup, in order for the backend server to use the correct uuid for players.
[Spigot](https://www.spigotmc.org/wiki/bungeecord-ip-forwarding/) [Sponge](https://docs.spongepowered.org/s ... ted/bungeecord.html). SpongeForge 推荐使用 [HexaCord](https://github.com/HexagonMC/BungeeCord), 这是一个 BungeeCord 分支，支持 Forge 的 IP forwarding。
Guides for this can be found [here for Spigot](https://www.spigotmc.org/wiki/bungeecord-ip-forwarding/), and [here for Sponge](https://docs.spongepowered.org/s ... ted/bungeecord.html). SpongeForge users are advised to use [HexaCord](https://github.com/HexagonMC/BungeeCord), a BungeeCord fork, which supports IP forwaring for Forge.
如果你的 BungeeCord 代理运行于离线模式并且你使用了 Spigot，你也应该像下方一样开启 IP forwarding，但是推荐你安装 [Paper](https://ci.destroystokyo.com/job/PaperSpigot/) 并设置 paper.yml 中的 `bungee-online-mode: false`。
If your BungeeCord proxy is running in offline mode & you are running Spigot, you should still be setting up ip forwarding as described above. However, it is reccomended that you install [Paper](https://ci.destroystokyo.com/job/PaperSpigot/) and set `bungee-online-mode: false` in paper.yml.
如果还有什么原因导致了你无法设置 Ip forwarding，你可能需要将其设置为 false，请确保这样做之前你知道这样做的后果。
If for whatever reason you are unable to setup IP forwarding, you may need to set this option to false. Make sure you are aware of the consequences before you do this.

##### 示例
```yaml
use-server-uuids: true
```

___
### `log-notify`
当任何权限被修改后是否向玩家发送长的提醒。提醒将只发送给拥有正确权限的用户。
If the plugin should send log notifications to users whenever permissions are modified. Notifications are only sent to those with the appropriate permission to recieve the notification.
提醒可以在游戏中使用 `/lp log notify off` 临时关闭。
Notifications can also be disabled temporarily in-game using `/lp log notify off`

##### 示例
```yaml
log-notify: true
```

___
### `world-rewrite`
允许你给发送的世界设置别名，别名附加于真正的世界名，递归应用。
Allows you to set "aliases" for the worlds sent forward for context calculation. These aliases are provided in addittion to the real world name. Applied recursively.

##### 示例
```yaml
world-rewrite:
  world_nether: world
  world_the_end: world
```

___
### `group-name-rewrite`
允许你设置组名的别名。它们是纯粹的显示名称，实际上的名称不会改变，只有命令/信息的输出会改变。
Allows you to set "aliases" for group names. These are purely display names, the actual underlying name of the group does not change. Only the output in commands/messages are affected.

##### 示例
```yaml
group-name-rewrite:
  default: Member
```

___
### `temporary-add-behaviour`
控制临时的权限/父类/元数据，默认是 `deny`
Controls how temporary permissions/parents/meta should be accumulated. The default behaviour is `deny`.
* accumulate - 任何添加的节点将被添加
* **`accumulate`** - the duration of any existing nodes will just be added to the new duration
* replace - 临时的节点持续的最长的时间，其他的节点将被忽略
* **`replace`** - the longest duration will be kept, any others nodes will be forgotten
* deny - 如果你试图添加一个重复的临时节点命令将被拒绝
* **`deny`** - the command will just fail if you try to add a duplicate temporary node

##### 示例
```yaml
temporary-add-behaviour: deny
```

___
### `primary-group-calculation`
LuckPerms 如何决定用户的主组，Bukkit/Bungee 默认的是 `stored`，Sponge 默认的是 `parents-by-weight`。
How should LuckPerms determine a users "primary" group. The default behaviour for Bukkit/Bungee is `stored`, and the default for Sponge is `parents-by-weight`.
* stored - 使用存储的记录在文件/数据库的数据
* **`stored`** - use the value stored against the users record in the file/database
* parents-by-weight - 使用用户权重最高的父组
* **`parents-by-weight`** - use the users most highly weighted parent
* all-parents-by-weight - 像上面的一样，但是计算所有的继承，包括直接继承和间接继承
* **`all-parents-by-weight`** - same as above, but calculates based upon all parents inherited from both directly and indirectly

##### 示例
```yaml
primary-group-calculation: stored
```

___

## Permission Calculation
___
### `apply-wildcards`
插件是否应用带有通配符的权限。
If the plugin should apply wildcard permissions.
如果插件的作者没有提供他们自己的通配符权限，那么开启这个选项将会让 LuckPerms 转换它们。Bukkit 尤其不认同这种做法，但是它们在管理员中间适用的相当普遍。在 Sponge，这个选项控制 "node.part.*" 类型的通配符是否生效。
If plugin authors do not provide their own wildcard permissions, then enabling this option will allow LuckPerms to parse them instead. Bukkit especially did not endorse this practice, however it has become common among server administrators. On Sponge, this setting control whether "node.part.*" style wildcards will function.

##### 示例
```yaml
apply-wildcards: true
```

___
### `apply-regex`
插件是否转换正则表达式权限。
If the plugin should parse regex permissions.
如果设置为 true，LuckPerms 将会检测任何正则表达式权限，正则表达式权限节点以 "r=" 开头，返回所有匹配这个节点的请求。如果你没有任何正则表达式权限的设置，开启这个将没有任何性能的影响。这个特点的更多信息可以在[这里](https://github.com/lucko/LuckPerms/wiki/Advanced-Setup#regex)找到。
If set to true, LuckPerms will detect any regex permissions, marked with "r=" at the start of the node, and return all requests matching the node. If you do not have any regex permissions setup, enabling this option will have no impact on performance. More info on this feature can be found [here](https://github.com/lucko/LuckPerms/wiki/Advanced-Setup#regex).

##### 示例
```yaml
apply-regex: true
```

___
### `apply-shorthand`
是否允许GLOB风格的速记权限。
If the plugin should resolve and apply any shorthand (GLOB style) permissions.
更多这个特性的信息可以在[这里](https://github.com/lucko/LuckPer ... orthand-permissions)找到。
More info on this feature can be found [here](https://github.com/lucko/LuckPer ... orthand-permissions).

##### 示例
```yaml
apply-shorthand: true
```

___
### `apply-bukkit-child-permissions`
插件是否应用Bukkit子权限。
If the plugin should apply Bukkit child permissions.
插件的作者可以给他们的插件定义自定义权限结构，如果设置为 true，LuckPerms 将会使用他们。
Plugin authors can define custom permissions structures for their plugin, which will be resolved and used by LuckPerms if this setting is enabled.
这个选项是默认启用的，因为这是一个基础的Bukkit特性，大多数的服务器管理员都需要，但是如果你不希望使用这个系统，它将可以被安全关闭。
This is enabled by default, as it is a standard Bukkit feature, which most server admins expect to work. However, if you'd prefer not to use this system, it can be safely disabled.

##### 示例
```yaml
apply-bukkit-child-permissions: true
```

___
### `apply-bukkit-default-permissions`
插件是否应该应用Bukkit的默认权限。
If the plugin should apply Bukkit default permissions.
插件作者可以给所有的用户默认权限，或者设置应该/不应该给OP玩家。如果这个设置为 false，LuckPerms将会忽略这些默认权限。
Plugin authors can define permissions which should be given to all users by default, or setup permissions which should/shouldn't be given to opped players. If this option is set to false, LuckPerms will ignore these defaults.
这个选项是默认启用的，因为这是一个基础的Bukkit特性，大多数的服务器管理员都需要，但是如果你不希望使用这个系统，它将可以被安全关闭。
This is enabled by default, as it is a standard Bukkit feature, which most server admins expect to work. However, if you'd prefer not to use this system, it can be safely disabled.

##### 示例
```yaml
apply-bukkit-default-permissions: true
```

___
### `apply-bukkit-attachment-permissions`
插件是否应该应用Bukkit的附加权限。
If the plugin should apply Bukkit attachment permissions.
服务器的其他插件可以添加它们自身的"权限附加"到玩家，这允许大量的玩家附加权限持续到回话结束，或者被移除。如果这个设置被设置为 false，LuckPerms 在考虑玩家是否有某一特定的权限时，将不会包括这些附加的权限。
Other plugins on the server are able to add their own "permission attachments" to players. This allows them to grant players additional permissions which last until the end of the session, or until they're removed. If this option is set to false, LuckPerms will not include these attachment permissions when considering if a player should have access to a certain permission.
你在开启这个选项后可能会见到一个小的性能提升，关闭 OP 系统后，这个系统可以非常有效的阻止恶意插件给玩家任意权限的尝试。
You may also see a slight performance improvement by enabling this feature. Combined with disabling the OP system, this system can be quite effective at disabling malicious attempts by plugins to grant arbitrary permissions to players.
这个选项是默认启用的，因为这是一个基础的Bukkit特性，大多数的服务器管理员都需要，但是如果你不希望使用这个系统，它将可以被安全关闭。
This is enabled by default, as it is a standard Bukkit feature, which most server admins expect to work. However, if you'd prefer not to use this system, it can be safely disabled.

##### 示例
```yaml
apply-bukkit-attachment-permissions: true
```

___
### `apply-bungee-config-permissions`
插件是否应用 BungeeCord config.yml 里设置的权限和组。
If the plugin should apply the permissions & groups defined in the BungeeCord config.yml
如果设置为 false，LuckPerms 将会忽略这些值。
If set to false, LuckPerms will ignore these values.
这个是默认关闭的，因为所有的权限都应该通过 LuckPerms 来设置，这样他们可以在游戏中查看和编辑。
This is disabled by default, as permissions should really be defined within LuckPerms, so they can be viewed and edited in-game alongside everything else.

##### 示例
```yaml
apply-bungee-config-permissions: false
```

___
### `apply-sponge-implicit-wildcards`
插件是否解析并应用Sponge的通配符集成系统的权限。
If the plugin should resolve and apply permissions according to Sponge's implicit wildcard inheritance system.
如果一个玩家获得了 `example`，那么他将自动获得 `example.function` 权限，`example.another`，`example.deeper.nesting` 等。
That being: If a user has been granted `example`, then the player should have also be automatically granted `example.function`, `example.another`, `example.deeper.nesting`, and so on.
如果这个选项被设置为 false，系统将不会被应用。
If this option is set to false, this system will not be applied.
这个选项是默认启用的，因为这是一个基础的Sponge特性，大多数的服务器管理员都需要，但是如果你不希望使用这个系统，它将可以被安全关闭。
This is enabled by default, as it is a standard Sponge feature, which most server admins / plugin authors expect to work. However, if you'd prefer not to use this system, it can be disabled.

##### 示例
```hocon
apply-sponge-implicit-wildcards=true
```

___
### `apply-sponge-default-subjects`
插件是否应用Sponge的默认权限。
If the plugin should apply Sponge default subject permissions.
插件将会授予玩家一组默认权限，如果设置为 false，那么插件将在考虑玩家是否拥有某权限时忽略这一组权限。
Plugins can manipulate a set of default permissions granted to all users. If this option is set to false, the plugin will ignore this data when considering if a player has a permission.
这个选项是默认启用的，因为这是一个基础的Sponge特性，大多数的服务器管理员都需要，但是如果你不希望使用这个系统，它将可以被安全关闭。
This is enabled by default, as it is a standard Sponge feature, which most server admins / plugin authors expect to work. However, if you'd prefer not to use this system, it can be disabled.

##### 示例
```hocon
apply-sponge-default-subjects=true
```

## Server Operator / Vault (Bukkit version only)
___
### `enable-ops`
是否使用原版的OP系统。
If the vanilla OP system should be used.
如果设置为 false，所有玩家都不是 op，op/deop 命令将被禁止。
If set to false, all users will be de-opped, and the op/deop commands will be disabled.

##### 示例
```yaml
enable-ops: true
```

___
### `auto-op`
如果设置为 true，任何拥有 "luckperms.autoop" 权限的玩家将会自动设置为服务器OP。
If set to true, any user with the permission "luckperms.autoop" will automatically be granted server operator status.
这个权限可以被继承，或者设置在特定的服务器/世界，临时的等等。另外，设置此选项为 true 将会强制上方的选项 "enable-ops" 为 false。所有的用户都将被 deop 直到他们有了这个权限节点，并且 op/deop 命令将被禁止。
This permission can be inherited, or set on specific servers/worlds, temporarily, etc. Additionally, setting this to true will force the "enable-ops" option above to false. All users will be de-opped unless they have the permission node, and the op/deop commands will be disabled.
有一点需要注意的是，自动OP检测只有在玩家进入服务器和切换世界时生效，这意味着，简单的移除他们的权限并不会自动去除玩家的OP，玩家必须重新登陆才能使其生效。
It is important to note that this setting is only checked when a player first joins the server, and when they switch worlds. Therefore, simply removing this permission from a user will not automatically de-op them. A player may need to relog to have the change take effect.
推荐使用这个选项而不是简单的分配一个 "*" 权限。
It is recommended that you use this option instead of assigning a single '*' permission.

##### 示例
```yaml
auto-op: false
```

___
### `commands-allow-op`
OP玩家是否有权限使用 LuckPerms 指令。
If opped players should be allowed to use LuckPerms commands.
设置为 false 将只允许有命令指定的权限的玩家使用。
Set to false to only allow users who have the permissions access to the commands

##### 示例
```yaml
commands-allow-op: true
```

___
### `use-vault-server`
下方的 `vault-server` 选项是否应该使用。
If the `vault-server` option below should be used.
当这个选项设置为 false 时，"server" 值用于 Vault 操作。
When this option is set to false, the server value defined above under "server" is used for Vault operations.

##### 示例
```yaml
use-vault-server: false
```

___
### `vault-server`
Vault 操作中使用的服务器名称。
The name of the server used within Vault operations.
如果你不想让 Vault 操作为特定服务器，将其设置为 "global"。
If you don't want Vault operations to be server specific, set this to "global".
只有当 `use-vault-server` 设置为 true 时生效。
Will only take effect if `use-vault-server` is set to true above.

##### 示例
```yaml
vault-server: global
```

___
### `vault-include-global`
玩家组接受元数据时是否考虑全局权限。
If global permissions should be considered when retrieving meta or player groups.

##### 示例
```yaml
vault-include-global: true
```

___
### `vault-ignore-world`
Vault 操作是否应该忽略提供的世界参数。
If Vault operations should ignore any world arguments if supplied.
默认情况下，如果没有提供世界参数，权限将会设置在玩家当前的世界。（Vault 的设计给满分）。设置为 true 来更改这项操作的结果。
By default, if a world argument is not supplied, permissions will be set on the players current world. (Vault design is just 10/10). Set this to true to change this behaviour.

##### 示例
```yaml
vault-ignore-world: false
```

___
### `vault-debug`
LuckPerms 是否应当在一个插件使用了 Vault 的功能后打印 debug 信息。
If LuckPerms should print debugging info to console when a plugin uses a Vault function

##### 示例
```yaml
vault-debug: false
```

## Storage
___
### `storage-method`
插件应该使用哪个存储方法。
Which storage method the plugin should use.
查看[这里](https://github.com/lucko/LuckPerms/wiki/Choosing-a-Storage-type)查看支持的所有类型。
See [here](https://github.com/lucko/LuckPerms/wiki/Choosing-a-Storage-type) for a full list of supported types.
接受： `mysql`, `mariadb`, `postgresql`, `sqlite`, `h2`, `json`, `yaml`, `mongodb`
**Accepts:** `mysql`, `mariadb`, `postgresql`, `sqlite`, `h2`, `json`, `yaml`, `mongodb`
如果你的 MySQL 支持，那么 `mariadb` 选项比 `mysql` 更好，`h2` 当然也比 `sqlite` 更好。
If your MySQL server supports it, the `mariadb` option is preferred over `mysql`. `h2` is also generally preferred over `sqlite`.

##### 示例
```yaml
storage-method: h2
```

___
### `watch-files`
当使用基于文件的存储系统，LuckPerms将会监视数据文件的变化，并在文件变化被检测到的时候自动规划更新数据、
When using a file-based storage type, LuckPerms will monitor the data files for changes, and then schedule automatic updates when changes are detected.
如果不想让这个发生，那么将此选项设置为 false。
If you don't want this to happen, set this option to false.

##### 示例
```yaml
watch-files: true
```

___
### `split-storage`
分离存储允许你为不用的数据类型使用不同的存储选项。
The split storage section allows you to use multiple storage options for different types of data.
不同类型的数据有：
**The different types of data are:**
* user - 关于用户的数据，包含权限、父组和元数据
* **`user`** - data about users, including their permissions, parents and meta
* group - 关于组的数据，包括了组权限、继承组和元数据
* **`group`** - data about groups, including their permissions, parents and meta
* track - 关于轨道的数据（或者说是梯子）
* **`track`** - data about tracks (or so called "ladders")
* uuid - LuckPerms 适用的 `uuid <-- --> username` 缓存，当 `/lp user` 使用的是用户名而不是 UUID
* **`uuid`** - a cache of `uuid <-- --> username` used by LuckPerms when usernames are used in the `/lp user` command instead of uuids.
* log - LuckPerms 存储的日志
* **`log`** - the action log stored by LuckPerms
允许的数据类型在上方列出
The allowed storage types are detailed above.

##### 示例
```yaml
split-storage:
  enabled: true
  methods:
user: mariadb
group: yaml
track: yaml
uuid: mariadb
log: mariadb
```

___
### `data`
此选项用于指定数据库的存储凭据。
This section is used for specifying credentials used for storage methods.

* address - 数据库的地址，如果使用默认的端口可以不填写，如果使用了特定端口，请使用 `host:port`
* **`address`** - the host to be used for the database. Uses the standard DB engine port by default. If you have a non-default port, specify it here using `host:port`.
* database - LuckPerms 应该使用的数据库
* **`database`** - the database which should be used by LuckPerms
* username - 使用的用户名
* **`username`** - the username to be used
* password - 使用的密码，留空则不使用验证
* **`password`** - the password to be used. Leave empty to use no authentication.

##### 示例
```yaml
data:
  address: localhost
  database: minecraft
  username: root
  password: ''
```

___
### `pool-size`
MySQL 连接池大小。
The size of the MySQL connection pool.
默认为 `10`，应该适合大部分服务器。只有你清楚你在干什么再更改这项设置。
By default this option is set to `10`, which should be fine for most servers. Only change this option if you know what you're doing.
查看[这里](https://github.com/brettwooldrid ... i/About-Pool-Sizing)了解更多关于连接池大小的信息。
See [here](https://github.com/brettwooldrid ... i/About-Pool-Sizing) for more details about pool sizing.

##### 示例
```yaml
data:
  pool-size: 10 # The size of the MySQL connection pool.
```

___
### `sync-minutes`
此选项控制 LuckPerms 多长时间进行一次同步任务。
This option controls how frequently LuckPerms will perform a sync task.
同步任务将会刷新存储中的所有信息，保证插件使用的是最新的数据。
A sync task will refresh all data from the storage, and ensure that the most up-to-date data is being used by the plugin.
这个选项默认关闭，因为大多数的用户都是不需要这个功能的，但是如果你使用远程存储，又没有设置信息服务，那么你可能将其设置为像 3 这样的数值。
This is disabled by default, as most users will not need it. However, if you're using a remote storage type without a messaging service setup, you may wish to set this value to something like 3.
设置为 -1 来完全停用这个任务。
Set to -1 to disable the task completely.

##### 示例
```yaml
data:
  sync-minutes: 3
```

___
### `messaging-service`
设置信息服务。
Settings for the messaging service.
如果开启并且正确配置了，LuckPerms 可以使用消息系统来通知其他连接的服务器更改。使用命令 `/luckperms networksync` 来推送更改，使用这个服务不会存储数据，只是用于消息平台。
If enabled and configured, LuckPerms will use the messaging system to inform other connected servers of changes. Use the command "/luckperms networksync" to push changes. Data is NOT stored using this service. It is only used as a messaging platform.
如果你决定开启这个功能，你应该设置 "sync-minutes" 为 -1，因为没有必要将数据推至数据库。
If you decide to enable this feature, you should set "sync-minutes" to -1, as there is no need for LuckPerms to poll the database for changes.
可用的选项
**Available options:**

* bungee - 使用插件的 messaging channel。必须在所有的子服务器开启才能使用，并且要在 Bungee 安装 LuckPerms。
* **`bungee`** - uses the plugin messaging channels. Must be enabled on all connected servers to work, and you need to have LP installed on your proxy.
* lilypad - 使用 LilyPad 的 pub sub 来推送更改。你需要安装 LilyPad-Connect 插件。
* **`lilypad`** - uses LilyPad's pub sub to push changes. You need to have the LilyPad-Connect plugin installed.
* redis - 使用 Redis 的 pub sub 来推送更改。
* **`redis`** - uses Redis pub sub to push changes.
* none - 啥都没有！
* **`none`** - nothing!

##### 示例
```yaml
messaging-service: none
```

___
### `auto-push-updates`
LuckPerms 是否应该在命令执行后自动推送更改。
If LuckPerms should automatically push updates after a change has been made with a command.

##### 示例
```yaml
auto-push-updates: true
```

___
### `redis`
Redis的设定。
Settings for Redis.

* address - redis 使用的地址，默认使用默认端口（6379），如果你有特定的端口，请使用 `host:port`。
* **`address`** - the host to be used for redis. Uses the standard port by default (6379). If you have a non-default port, specify it here using `host:port`.
* password - 使用 Redis 需要的密码。留空则不使用验证。
* **`password`** - the password to be used. Leave empty to use no authentication.

##### 示例
```yaml
redis:
  enabled: true
  address: localhost
  password: 'passw0rd'
```

Admin	Mod	Default
minecraft.command.ban	minecraft.command.mute	minecraft.command.say
minecraft.command.pardon	minecraft.command.unmute	minecraft.command.me
some.cool.admin.perm	some.cool.mod.perm
someplugin.vanish	chatcolor.bold