36 | * Annotation that defines a handler. 37 | * 38 | *
一个处理器的重要程度被称作处理器的优先级，优先级高的处理器有更多的决定权。参见：{@link #priority()}
39 | * The importance of a handler is called its priority, handlers with higher priority speaks louder then
40 | * lower ones. See: {@link #priority()}
处理器可以选择忽略或不忽略被取消的事件，这种特性可以在{@link #ignoreCancelled()}中定义。
43 | * A handler can choose to ignore a cancelled event or not, that can be defined in {@link #ignoreCancelled()}.
57 | * Define the priority of the handler. 58 | * 59 | *
Nukkit调用处理器时会按照优先级从低到高的顺序调用，这样保证了高优先级的监听器能覆盖低优先级监听器做出的处理。
60 | * 调用的先后顺序如下：
-
65 | *
- EventPriority.LOWEST 66 | *
- EventPriority.LOW 67 | *
- EventPriority.NORMAL 68 | *
- EventPriority.HIGH 69 | *
- EventPriority.HIGHEST 70 | *
- EventPriority.MONITOR 71 | *
The priority of this handler. 74 | * @see cn.nukkit.event.EventHandler 75 | */ 76 | EventPriority priority() default EventPriority.NORMAL; 77 | 78 | /** 79 | * 定义这个处理器是否忽略被取消的事件。
80 | * Define if the handler ignores a cancelled event. 81 | * 82 | *
如果为{@code true}而且事件发生，这个处理器不会被调用，反之相反。
83 | * If ignoreCancelled is {@code true} and the event is cancelled, the method is
84 | * not called. Otherwise, the method is always called.
Whether cancelled events should be ignored. 87 | * @see cn.nukkit.event.EventHandler 88 | */ 89 | boolean ignoreCancelled() default false; 90 | } 91 | 92 | ``` 93 | 第一个是优先级，第二个是是否忽略事件被取消 94 | 95 | 默认的优先级是normal,从注释可以知道，这是他们的先后顺序，LOWEST会最先被调用，其次是LOW，最后是MONITOR，如果在LOWEST监听器中调用了Event.setCancelled(true)，Nukkit则会忽略掉后面的 ignoreCancelled 被设置为true或者保持默认的优先级更高的监听器 96 | 97 | - EventPriority.LOWEST 98 | 99 | - EventPriority.LOW 100 | 101 | - EventPriority.NORMAL 102 | 103 | - EventPriority.HIGH 104 | 105 | - EventPriority.HIGHEST 106 | 107 | - EventPriority.MONITOR 108 | 109 | 而实现监听器的优先级标记是通过 **枚举(Enum)** 实现的 110 | 111 | 优先级的目的是为了保证监听器按照顺序执行，以使得一个监听器操作完会 112 | 进入下一个监听器继续执行，以确保执行的有序性。下一个监听器的相同操作 113 | 会覆盖之前监听器的相同操作。 114 | 115 | 同时，事件可以被我手动取消的，但是有时候事件虽然取消，但依然需要操作， 116 | 那么ignoreCancelled可以发挥作用了,当然默认是忽略掉取消的事件，也就是 117 | 说取消的事件默认不会被监听(这里可能有所错误，我这个不太常用) 118 | 119 | 一个EventHandler基本都是监听一个事件的(我只尝试过一个事件的)，代码中 120 | 这样使用 121 | ```java 122 | package net.noyark.www; 123 | 124 | import cn.nukkit.event.EventHandler; 125 | import cn.nukkit.event.Listener; 126 | import cn.nukkit.event.player.PlayerJoinEvent; 127 | 128 | public class OtherListener implements Listener { 129 | 130 | @EventHandler 131 | public void onPlayerJoin(PlayerJoinEvent e){ 132 | //执行代码 133 | } 134 | } 135 | 136 | ``` 137 | 这里的意思就是当玩家进入服务器时，就会触发PlayerJoinEvent事件，服务器会 138 | 形成一个PlayerJoinEvent对象，并且调用先前注册的有关PlayerJoinEvent的 139 | EventHandler，将对象传入，这样就实现了一个 **事件的调用** 140 | 获取对象的内容，则通过e调用即可，我们不需要很明白它的具体细节，只需要知道， 141 | 使用EventHandler注解的方法(且有一个Event的子类类型参数，并且它所在的监听器被注册)， 142 | 就会在事件发生时，相应的被调用，如上文所讲，这里的代码案例就是当发生玩家加入时， 143 | 这个onPlayerJoin方法会被服务端调用。 144 | ```java 145 | package net.noyark.www; 146 | 147 | import cn.nukkit.event.EventHandler; 148 | import cn.nukkit.event.Listener; 149 | import cn.nukkit.event.player.PlayerJoinEvent; 150 | 151 | public class OtherListener implements Listener { 152 | 153 | @EventHandler 154 | public void onPlayerJoin(PlayerJoinEvent e){ 155 | e.getPlayer().sendMessage("你好 "+e.getPlayer()); 156 | } 157 | } 158 | ``` 159 | 例如这个代码，在玩家加入时，将会向玩家发送一个"你好 玩家的名字"，这就是 160 | 我们监听器的作用 161 | ```java 162 | package net.noyark.www; 163 | 164 | import cn.nukkit.event.EventHandler; 165 | import cn.nukkit.event.EventPriority; 166 | import cn.nukkit.event.Listener; 167 | import cn.nukkit.event.player.PlayerJoinEvent; 168 | 169 | public class OtherListener implements Listener { 170 | 171 | @EventHandler(priority = EventPriority.HIGH,ignoreCancelled = true) 172 | public void onPlayerJoin(PlayerJoinEvent e){ 173 | e.getPlayer().sendMessage("你好 "+e.getPlayer()); 174 | } 175 | } 176 | ``` 177 | 如果要使用我们之前所说的参数，则这样使用。 178 | 179 | 事实上，监听器的基本使用方式也就这些，nukkit也提供了很多事件给予我们使用，也允许我们 180 | 自己制作事件自己使用，在第二部分中，我们将会讲解提供了哪些事件 181 | 182 | 如何自己定义一个事件 183 | 184 | 事实上，nukkit的事件是通过callEvent调用的，所以，我们同样可以通过callEvent实现我们自己 185 | 的事件。 186 | ``` 187 | this.getServer().getPluginManager().callEvent(Event e); 188 | ``` 189 | 首先我们先定义一个事件类 190 | ```java 191 | package net.noyark.www; 192 | 193 | import cn.nukkit.event.Event; 194 | 195 | public class MyEvent extends Event { 196 | } 197 | 198 | ``` 199 | 之后，我们在监听器使用我们的事件 200 | ```java 201 | package net.noyark.www; 202 | 203 | import cn.nukkit.event.EventHandler; 204 | import cn.nukkit.event.Listener; 205 | 206 | 207 | public class OtherListener implements Listener { 208 | 209 | @EventHandler 210 | public void onMy(MyEvent e){ 211 | 212 | } 213 | } 214 | ``` 215 | 之后，我们就可以使用我们的事件了。 216 | ``` 217 | this.getServer().getPluginManager().registerEvents(new OtherListener(),this); 218 | ``` 219 | 如何触发我们的事件？ 220 | 事件的触发则通过callEvent触发，假如，我们写一个玩家假如时，如果他的 221 | 名字叫abc，就触发MyEvent事件 222 | ```java 223 | package net.noyark.www; 224 | 225 | import cn.nukkit.event.EventHandler; 226 | import cn.nukkit.event.Listener; 227 | import cn.nukkit.event.player.PlayerJoinEvent; 228 | 229 | 230 | public class OtherListener implements Listener { 231 | 232 | @EventHandler 233 | public void onMy(MyEvent e){ 234 | 235 | } 236 | 237 | @EventHandler 238 | public void onPLayerJoin(PlayerJoinEvent e){ 239 | if("abc".equals(e.getPlayer().getName())){ 240 | Example.getPlugin().getServer() 241 | .getPluginManager() 242 | .callEvent(new MyEvent()); 243 | } 244 | } 245 | } 246 | 247 | ``` 248 | 这里，我们完成了我们的自定义事件 249 | 250 | 假如我们要注册一个EventHandler，不去注册其他的该如何。 251 | 事实上，可以实现这个，nukkit提供了registerEvent方法， 252 | 可以注册单个EventHandler，但不太常用，我这里也不会再过多 253 | 阐述了，如果想了解，可以发issue，我将会添加这方面的内容 254 | 255 | [上一节](1-2_了解PluginBase.md) [下一节](1-4_如何编写命令.md) 256 | -------------------------------------------------------------------------------- /第一章/1-4_如何编写命令.md: -------------------------------------------------------------------------------- 1 | [上一节](1-3_如何编写监听器.md) [下一节](1-5_如何使用配置文件.md) 2 | 3 | # 第一章 第四节 如何编写命令 4 | 参与编写者: MagicLu550 5 | #### 建议学习时间: 30分钟 6 | ##### 学习要点: 学习自己创建一个简易的命令,了解指令和指令映射,了解SimpleCommand的使用 7 | 8 | 其实创建一个简易的命令很简单，我们可以在`PluginBase`中重写`onCommand`方法，进行`equals`识别，比如 9 | ```java 10 | public class PluginMain extends PluginBase{ 11 | //... 其他 12 | @Override 13 | // args指后面的那一串参数，直接取出即可，注意先检查length，label其实就是指令名称，也可以用command的信息，这个是个人习惯 14 | public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { 15 | if("hello".equals(command.getName())){ // 识别指令名称 16 | this.getLogger().info("hello!"); 17 | return true; 18 | } 19 | return false; 20 | } 21 | } 22 | 23 | ``` 24 | 25 | nukkit的原生命令也是很多基于Command创建的.很多项目是需求指令 26 | 以使得用户和您的项目操作，也就是作为一个 **接口(Interface)** ,接下来我们介绍以下nukkit的命令。 27 | 28 | nukkit的命令的父类是Command，它有很多的构造方法 29 | ``` 30 | public Command(String name) { 31 | this(name, "", null, new String[0]); 32 | } 33 | 34 | public Command(String name, String description) { 35 | this(name, description, null, new String[0]); 36 | } 37 | 38 | public Command(String name, String description, String usageMessage) { 39 | this(name, description, usageMessage, new String[0]); 40 | } 41 | 42 | public Command(String name, String description, String usageMessage, String[] aliases) { 43 | this.commandData = new CommandData(); 44 | this.name = name.toLowerCase(); // Uppercase letters crash the client?!? 45 | this.nextLabel = name; 46 | this.label = name; 47 | this.description = description; 48 | this.usageMessage = usageMessage == null ? "/" + name : usageMessage; 49 | this.aliases = aliases; 50 | this.activeAliases = aliases; 51 | this.timing = Timings.getCommandTiming(this); 52 | this.commandParameters.put("default", new CommandParameter[]{new CommandParameter("args", CommandParamType.RAWTEXT, true)}); 53 | } 54 | ``` 55 | 我们可以知道，nukkit的命令都是toLowerCase的，即小写，也就是说，命令不区分大小写。 56 | 对于命令如何存储，服务端如何识别一个命令，我们从源码中找到以下资料: 57 | 58 | -- 59 | 60 | 命令的区分标识是fallBackPrefix+:+label，默认为指令的名称，一般fallBackPrefix都写"" 61 | 62 | 这一块知识缺点将会有其他人补充[1] 63 | 64 | 代码依据 - SimpleCommandMap.java 65 | ``` 66 | 159 private boolean registerAlias(Command command, boolean isAlias, String fallbackPrefix, String label) { 67 | 160 this.knownCommands.put(fallbackPrefix + ":" + label, command); 68 | 69 | ``` 70 | -- 71 | 72 | 73 | 存储指令的容器是实现CommandMap接口的，即SimpleCommandMap,我们可以通过 74 | ``` 75 | this.getServer().getCommandMap(); 76 | ``` 77 | 得到CommandMap. 78 | 79 | Command,CommandMap有很多方法 80 | 81 | 1. Command 82 | 1. 根构造方法的参数为 83 | ``` 84 | String name, String description, String usageMessage, String[] aliases 85 | 86 | 第一个name是指令名称，最终会转换为全小写 87 | 88 | 第二个description是指令介绍，用于给玩家查看使用的 89 | 90 | 第三个usageMessage就是当玩家对命令使用错误，返回的信息 91 | 92 | 第四个aliases就是指令的别名，指令可以有多个别名 93 | ``` 94 | 当然，也有简化的构造方法，可以根据你的需求任意调用，这里不多阐述，其他的都是为默认值 95 | 2. Command的主要属性 96 | 如同command的构造方法一样,command我们需要了解的属性基本也就是这四个。其他属性将会 97 | 在nukkit原理解析的时候讲解 98 | 3. Command的比较常用的方法 99 | 1. boolean execute(CommandSender commandSender, String label, String[] strings) 100 | 101 | 这个方法是需要开发者自行实现的方法，当指令被触发，就会执行execute里的代码 102 | 它的参数我们在[第二章](1-2_插件要素.md)提到了 103 | 104 | 2. String getName() 105 | 106 | 这个可以获取指令的名称 107 | 108 | 其余方法我们将会在后期附件讲解到，如果有想要知悉的其他方法，我们会另外在这里做补充， 109 | 或者您认为常用的，也可以pull request添加进去 110 | 111 | 2. CommandMap 112 | 1. boolean register(String fallbackPrefix, Command command) 113 | 可以注册指令，fallbackPrefix是前缀，用于服务端存储命令对象的标识 114 | nukkit的本地命令的fallbackPrefix为nukkit 115 | command则为你的自定义命令对象 116 | 2. void registerAll(String fallbackPrefix, List commands) 117 | 这个可以一次性注册多个指令 118 | 3. boolean dispatch(CommandSender sender, String cmdLine) 119 | 这个调用一个命令，cmdLine就是日常所输入的命令 120 | 4. void registerSimpleCommands(Object object) 121 | 这个是调用简单指令，通过注解实现的指令对象，我们后面将会演示如何使用它。 122 | 123 | nukkit官方后来推出一系列简化操作，如SimpleCommand,SimpleConfig等，我们这里解释以下SimpleCommand 124 | 125 | SimpleCommand运用了注解，同样通过 **反射** 实现的,我们可以看到官方的源码来探讨它的使用 126 | 127 | SimpleCommandMap.java 128 | ``` 129 | @Override 130 | public void registerSimpleCommands(Object object) { 131 | for (Method method : object.getClass().getDeclaredMethods()) { 132 | cn.nukkit.command.simple.Command def = method.getAnnotation(cn.nukkit.command.simple.Command.class); 133 | if (def != null) { 134 | SimpleCommand sc = new SimpleCommand(object, method, def.name(), def.description(), def.usageMessage(), def.aliases()); 135 | 136 | Arguments args = method.getAnnotation(Arguments.class); 137 | if (args != null) { 138 | sc.setMaxArgs(args.max()); 139 | sc.setMinArgs(args.min()); 140 | } 141 | 142 | CommandPermission perm = method.getAnnotation(CommandPermission.class); 143 | if (perm != null) { 144 | sc.setPermission(perm.value()); 145 | } 146 | 147 | if (method.isAnnotationPresent(ForbidConsole.class)) { 148 | sc.setForbidConsole(true); 149 | } 150 | 151 | CommandParameters commandParameters = method.getAnnotation(CommandParameters.class); 152 | if (commandParameters != null) { 153 | Map
61 | * Indicates that the plugin will be loaded at startup. 62 | * 63 | * @see cn.nukkit.plugin.PluginLoadOrder 64 | * @since Nukkit 1.0 | Nukkit API 1.0.0 65 | */ 66 | STARTUP, 67 | /** 68 | * 表示这个插件在第一个世界加载完成后开始加载。
69 | * Indicates that the plugin will be loaded after the first/default world was created. 70 | * 71 | * @see cn.nukkit.plugin.PluginLoadOrder 72 | * @since Nukkit 1.0 | Nukkit API 1.0.0 73 | */ 74 | POSTWORLD 75 | ``` 76 | config里有一个load,分别为STARUP与POSTWORLD,前者使插件加载在地图之前,后者为使插件加载在地图之后,如果对地图加载有需求的话，必须填写POSTWORLD,否则将无法获取level 77 | 78 | 您也可以添加自己的网站: website属性 79 | 80 | [上一节](1-5_如何使用配置文件.md) [下一节](1-7_案例玩家进入信息等效果.md) 81 | -------------------------------------------------------------------------------- /第一章/1-7_案例玩家进入信息等效果.md: -------------------------------------------------------------------------------- 1 | [上一节](1-7_PluginBase类.md) [下一节](../第二章/2-0_前言.md) 2 | 3 | 4 | # 第一章 第七节 案例课:玩家进入案例演示 5 | 参与编写者: MagicLu550 6 | #### 建议学习时间: 30分钟 7 | ##### 学习要点: 对于之前知识的巩固和加深认识 8 | 9 | 这个项目的需求很简单.实现一个玩家加入自定义提示信息,可以手动取消信息的功能 10 | 我们列举下步骤 11 | - 创建项目 12 | - 导入nukkit包 13 | - 创建初始化配置文件set-info.yml 14 | - 创建plugin.yml 15 | - 创建主类 16 | - 创建配置 17 | 18 | - 创建监听器 19 | - 读取配置内容 20 | - 发送玩家信息 21 | - 创建命令 22 | -判断 23 | - 注册监听器和命令 24 | - 完成 25 | 26 | 1.第一到二步请自己完成 27 | 2.set-inf的内容 28 | ```yaml 29 | message: 欢迎${player}加入了服务器 30 | ``` 31 | 3.我的plugin.yml的内容 32 | ```yaml 33 | name: MyJoin 34 | main: net.noyark.www.MyJoin 35 | version: "0.0.1" 36 | author: magiclu550 37 | api: ["1.0.9"] 38 | description: My first plugin 39 | #当采用注册时，控制权限需要在这里声明 40 | commands: 41 | set: 42 | permission: myjoin.set 43 | permissions: 44 | myjoin.set: 45 | default: op 46 | ``` 47 | 4.创建主类 MyJoin 48 | ```java 49 | package net.noyark.www; 50 | 51 | import cn.nukkit.plugin.PluginBase; 52 | 53 | 54 | public class MyJoin extends PluginBase { 55 | 56 | private Map
53 | * Called on submitted 54 | * 55 | * @param listener 调用的方法 56 | */ 57 | public final ResponsibleFormWindowSimple onClicked(@NotNull BiConsumer
64 | * Called on submitted 65 | * 66 | * @param listener 调用的方法(无 Player) 67 | */ 68 | public final ResponsibleFormWindowSimple onClicked(@NotNull Consumer
75 | * Called on submitted 76 | * 77 | * @param listener 调用的方法(无参数) 78 | */ 79 | public final ResponsibleFormWindowSimple onClicked(@NotNull Runnable listener) { 80 | Objects.requireNonNull(listener); 81 | this.buttonClickedListener = (id, player) -> listener.run(); 82 | return this; 83 | } 84 | ``` 85 | 86 | - `Consumer`和`BiConsumer`都是接口`Interface`，我们可以使用 lambda 表达式直接写它的实现类。也可以用 匿名内部类去编写。 87 | 88 | - 最后 GUI 帮我们监听事件并执行我们在 `Consumer` 或 `BiConumer`的实现类中的`accept`方法。 89 | 90 | - 综上：我们无需监听事件，在写UI视图的同时也能将用户交互后的处理写完。 91 | 92 | 二. 代码部分 93 | 94 | - `FormSimple ` 构造方法 95 | 96 | ```java 97 | public FormSimple() { 98 | } 99 | 100 | public FormSimple(String content) { 101 | super(content); 102 | } 103 | 104 | public FormSimple(String title, String content) { 105 | super(title, content); 106 | } 107 | 108 | public FormSimple(String title, String content, String... buttons) { 109 | super(title, content, buttons); 110 | } 111 | 112 | public FormSimple(String title, String content, ElementButton... buttons) { 113 | super(title, content, buttons); 114 | } 115 | 116 | public FormSimple(String title, String content, @NotNull List
402 | 
403 | 
404 | 
405 | 
406 | 
407 | 
408 |
409 |
410 | ### 八、最后
411 |
412 | 一个简单的登录插件就编写完了。希望大家能够了解一些Event下面的方法，最重要的是去实践。无论是Eclipse还是IDEA，都自带了非常友好的提示功能。还有反编译。可以直接通过方法名，类名来了解Nukkit。
413 |
414 | 当然，这个插件还有一部分功能是残缺的，比如注册。有一些Event没有禁止掉，比如扔物品和捡起物品。这些都等待屏幕前的你来开发。
415 |
416 | [上一节](2-1_主要的事件介绍.md) [下一节](2-3_计时器的介绍.md)
417 |
--------------------------------------------------------------------------------
/第二章/2-3_计时器的介绍.md:
--------------------------------------------------------------------------------
1 | [上一节](2-2_事件相关方法.md) [下一节](2-4_Server类和PluginManager类.md)
2 | # 第二章 第三节 计时器的介绍
3 | 参与编写者：`zzz1999`
4 | #### 建议学习时间：3分钟
5 | ##### 学习要点：了解计时器的功能以及如何使用
6 |
7 | 一.概念
8 | 1.计时器的作用是 __立即，延时，循环或延时循环__ 某些任务,通过计时器我们可以实现例如 *在线奖励* , *倒计时* 等插件功能, 是一些复杂插件中经常用到的功能之一.
9 |
10 | 2.执行计时器代码块的单元叫做任务,我们可以编写任务代码来使用计时器的功能.
11 |
12 | 3.任务执行分为两种类型,一种是同步,一种是异步.同步通过主线程所调度管理执行,异步通过主线程调度管理,异步线程池执行.所以,太多的任务会导致服务器卡顿.
13 |
14 | 4.计时器的功能以`minecraft刻`(tick)作为单位,一刻为现实时间的0.05秒,现实时间的1秒为20刻,服务器每秒刻数由TPS决定,最高为20.
15 |
16 |
17 | 二.代码
18 |
19 | 我们先来看一下nukkit的[Task](https://github.com/NukkitX/Nukkit/blob/master/src/main/java/cn/nukkit/scheduler/Task.java)类.
20 |
21 | ```java
22 | package cn.nukkit.scheduler;
23 |
24 | import cn.nukkit.Server;
25 |
26 | /**
27 | * 表达一个任务的类。A class that describes a task. 28 | * 29 | *
一个任务可以被Nukkit服务器立即，延时，循环或延时循环执行。参见:{@link ServerScheduler}
30 | * A task can be executed by Nukkit server with a/an express, delay, repeat or delay&repeat.
31 | * See:{@link ServerScheduler}
对于插件开发者，为确保自己任务能够在安全的情况下执行（比如：在插件被禁用时不执行），
34 | * 建议让任务继承{@link PluginTask}类而不是这个类。
35 | * For plugin developers: To make sure your task will only be executed in the case of safety
36 | * (such as: prevent this task from running if its owner plugin is disabled),
37 | * it's suggested to use {@link PluginTask} instead of extend this class.
62 | * What will be called when the task is executed. 63 | * 64 | * @param currentTick 服务器从开始运行到现在所经过的tick数，20ticks = 1秒，1tick = 0.05秒。
65 | * The elapsed tick count from the server is started. 20ticks = 1second, 1tick = 0.05second. 66 | * @since Nukkit 1.0 | Nukkit API 1.0.0 67 | */ 68 | public abstract void onRun(int currentTick); 69 | 70 | @Override 71 | public final void run() { 72 | this.onRun(taskHandler.getLastRunTick()); 73 | } 74 | 75 | public void onCancel() { 76 | 77 | } 78 | 79 | public void cancel() { 80 | try { 81 | this.getHandler().cancel(); 82 | } catch (RuntimeException ex) { 83 | Server.getInstance().getLogger().critical("Exception while invoking onCancel", ex); 84 | } 85 | } 86 | 87 | } 88 | ``` 89 | 90 | 我们可以捕捉到几个关键信息,首先我们可以看到`onRun(int)`方法,它是一个抽象方法并且nk开发者很贴心的写上了注释示意我们这是Task中会被运行到代码块. 91 | 92 | 还有`onCancel()`和`cancel()`方法,onCancel()内部是一个空代码块,当Task被取消的时候(被任务调度器取消或者手动调用cancel()取消都会触发),这段代码块会被调用 93 | 94 | 比较常见的用途比如小游戏时间到的时候,一些判定胜负,给予奖励,关闭房间的一些代码可以用Task来实现或者调用. 95 | 96 | 我们还可以使用`cancel()`方法来强制取消一个Task,例如你想要写一个登录插件,每个玩家进入服务器时创建一个Task循环发送提示登录的信息,如果玩家输入了正确的密码并且登录成功才会取消掉这个Task.这时候就可以使用cancel方法了(仅举例,实际生产环境中,每个玩家进入创一个计时器是很费资源的,不会使用这种方法) 97 | 98 | Handler是服务器调度Task所用到的一些东西,可以不懂,不妨碍计时器的使用. 99 | 100 | 开发者可以使用`PluginBase#getServer()`方法获取到Server对象,然后使用`Server#getSchedule()`获取到计时器的实例类. 101 | ```java 102 | public class Main extends PluginBase{ 103 | @Override 104 | public void onEnable(){ 105 | ServerScheduler scheduler = this.getServer().getScheduler(); 106 | } 107 | } 108 | ``` 109 | 获取到后,可以创建 __立即，延时，循环或延时循环__ 类型的计时器 110 | 立即(ServerSchedule#scheduleTask) 111 | 延时(ServerSchedule#scheduleDelayedTask) 112 | 循环(ServerSchedule#scheduleRepeatingTask) 113 | 延时循环(ServerSchedule#scheduleDelayedRepeatingTask) 114 | 115 | 计时器是需要一个被触发的时间间隔的,以tick为单位,如果是循环计时器,则是每次循环的时间,如果是延时,则是延迟多少tick才被触发,如果是延迟循环,则会要求填写延迟间隔与循环间隔. 116 | 117 | 举例将会在下一小节讲到 118 | 119 | 3.使用 120 | 121 | 下面会使用到`PluginTask`类,你需要对`PluginTask`类的方法做一个初步的了解,以及知道它继承了Task类. 122 | ```java 123 | package cn.nukkit.scheduler; 124 | 125 | 126 | import cn.nukkit.plugin.Plugin; 127 | 128 | /** 129 | * 插件创建的任务。
Task that created by a plugin. 130 | * 131 | *
对于插件作者，通过继承这个类创建的任务，可以在插件被禁用时不被执行。
132 | * For plugin developers: Tasks that extend this class, won't be executed when the plugin is disabled.
另外，继承这个类的任务可以通过{@link #getOwner()}来获得这个任务所属的插件。
135 | * Otherwise, tasks that extend this class can use {@link #getOwner()} to get its owner.
An example for plugin create a task: 138 | *
139 | * public class ExampleTask extends PluginTask<ExamplePlugin>{
140 | * public ExampleTask(ExamplePlugin plugin){
141 | * super(plugin);
142 | * }
143 | *
144 | * {@code @Override}
145 | * public void onRun(int currentTick){
146 | * getOwner().getLogger().info("Task is executed in tick "+currentTick);
147 | * }
148 | * }
149 | *
150 | *
151 | * 如果要让Nukkit能够延时或循环执行这个任务，请使用{@link ServerScheduler}。
152 | * If you want Nukkit to execute this task with delay or repeat, use {@link ServerScheduler}.
The plugin that owns this task. 155 | * @author MagicDroidX(code) @ Nukkit Project 156 | * @author 粉鞋大妈(javadoc) @ Nukkit Project 157 | * @since Nukkit 1.0 | Nukkit API 1.0.0 158 | */ 159 | public abstract class PluginTask
Constructs a plugin-owned task. 165 | * 166 | * @param owner 这个任务的所有者插件。
The plugin object that owns this task. 167 | * @since Nukkit 1.0 | Nukkit API 1.0.0 168 | */ 169 | public PluginTask(T owner) { 170 | this.owner = owner; 171 | } 172 | 173 | /** 174 | * 返回这个任务的所有者插件。
175 | * Returns the owner of this task. 176 | * 177 | * @return 这个任务的所有者插件。
The plugin that owns this task. 178 | * @since Nukkit 1.0 | Nukkit API 1.0.0 179 | */ 180 | public final T getOwner() { 181 | return this.owner; 182 | } 183 | 184 | } 185 | ``` 186 | 187 | 我们可以通过创建一个继承PluginTask的类来创建一个PluginTask(为什么不直接继承Task类?,因为这个类添加了`getOwner()`方法,可以通过构造方法传入一份主类或任意你需要类实例的引用,方便编写代码) 188 | 189 | ```java 190 | 191 | package net.noyark.NukkitLearn; 192 | 193 | import cn.nukkit.scheduler.PluginTask; 194 | 195 | public class NukkitLearnExampleTask extends PluginTask