Skip to content
This repository was archived by the owner on May 26, 2024. It is now read-only.

Commit ee21c16

Browse files
EuphillyaEuphillya
committed
Version 1.1.8
Création de SchedulerTaskRunnable qui est une inspiration de BukkitRunnable
1 parent 1e1c610 commit ee21c16

File tree

5 files changed

+251
-2
lines changed

5 files changed

+251
-2
lines changed

‎build.gradle.kts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ plugins {
44
}
55

66
group = "fr.euphyllia"
7-
version = "1.1.7"
7+
version = "1.1.8"
88

99
repositories {
1010
mavenCentral()

‎src/main/java/fr/euphyllia/energie/folia/FoliaScheduler.java‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,6 @@
66
import org.bukkit.Location;
77
import org.bukkit.entity.Entity;
88
import org.bukkit.plugin.Plugin;
9-
import org.checkerframework.checker.units.qual.C;
109
import org.jetbrains.annotations.NotNull;
1110
import org.jetbrains.annotations.Nullable;
1211

‎src/main/java/fr/euphyllia/energie/model/AbstractSchedulerTaskRunnable.java‎

Lines changed: 85 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,85 @@
1+
package fr.euphyllia.energie.model;
2+
3+
import org.bukkit.Location;
4+
import org.bukkit.entity.Entity;
5+
import org.bukkit.plugin.Plugin;
6+
import org.jetbrains.annotations.NotNull;
7+
import org.jetbrains.annotations.Nullable;
8+
9+
public abstract class AbstractSchedulerTaskRunnable {
10+
protected SchedulerTaskInter task;
11+
12+
/**
13+
* Returns true if this task has been cancelled.
14+
*
15+
* @return true if the task has been cancelled
16+
* @throws IllegalStateException if task was not scheduled yet
17+
*/
18+
protected synchronized boolean isCancelled() throws IllegalStateException {
19+
checkScheduled();
20+
return task.isCancelled();
21+
}
22+
23+
/**
24+
* Attempts to cancel this task.
25+
*
26+
* @throws IllegalStateException if task was not scheduled yet
27+
*/
28+
public abstract void cancel() throws IllegalStateException;
29+
30+
@NotNull
31+
public abstract SchedulerTaskInter runTask(@NotNull Plugin plugin, SchedulerType schedulerType) throws IllegalArgumentException, IllegalStateException;
32+
33+
public abstract @NotNull SchedulerTaskInter runTask(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, MultipleRecords.WorldChunk worldChunk);
34+
35+
public abstract @NotNull SchedulerTaskInter runTask(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, Location location);
36+
37+
public abstract @NotNull SchedulerTaskInter runTask(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, Entity entity, @Nullable Runnable retired);
38+
39+
@NotNull
40+
public abstract SchedulerTaskInter runDelayed(@NotNull Plugin plugin, SchedulerType schedulerType, long delay) throws IllegalArgumentException, IllegalStateException;
41+
42+
public abstract @NotNull SchedulerTaskInter runDelayed(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, MultipleRecords.WorldChunk worldChunk, long delayTicks);
43+
44+
public abstract @NotNull SchedulerTaskInter runDelayed(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, Location location, long delayTicks);
45+
46+
public abstract @NotNull SchedulerTaskInter runDelayed(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, Entity entity, @Nullable Runnable retired, long delayTicks);
47+
48+
@NotNull
49+
public abstract SchedulerTaskInter runAtFixedRate(@NotNull Plugin plugin, SchedulerType schedulerType, long delay, long period) throws IllegalArgumentException, IllegalStateException;
50+
51+
public abstract @NotNull SchedulerTaskInter runAtFixedRate(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, MultipleRecords.WorldChunk worldChunk, long initialDelayTicks, long periodTicks);
52+
53+
public abstract @NotNull SchedulerTaskInter runAtFixedRate(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, Location location, long initialDelayTicks, long periodTicks);
54+
55+
public abstract @NotNull SchedulerTaskInter runAtFixedRate(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, Entity entity, @Nullable Runnable retired, long initialDelayTicks, long periodTicks);
56+
57+
/**
58+
* Gets the task id for this runnable.
59+
*
60+
* @return the task id that this runnable was scheduled as
61+
* @throws IllegalStateException if task was not scheduled yet
62+
*/
63+
protected synchronized int getTaskId() throws IllegalStateException {
64+
checkScheduled();
65+
return task.getTaskId();
66+
}
67+
68+
protected void checkScheduled() {
69+
if (task == null) {
70+
throw new IllegalStateException("Not scheduled yet");
71+
}
72+
}
73+
74+
protected void checkNotYetScheduled() {
75+
if (task != null) {
76+
throw new IllegalStateException("Already scheduled as " + task.getTaskId());
77+
}
78+
}
79+
80+
@NotNull
81+
protected SchedulerTaskInter setupTask(@NotNull final SchedulerTaskInter task) {
82+
this.task = task;
83+
return task;
84+
}
85+
}

‎src/main/java/fr/euphyllia/energie/model/SchedulerRunnable.java‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,6 @@
1+
package fr.euphyllia.energie.model;
2+
3+
public interface SchedulerRunnable {
4+
5+
void run();
6+
}

‎src/main/java/fr/euphyllia/energie/utils/SchedulerTaskRunnable.java‎

Lines changed: 159 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,159 @@
1+
package fr.euphyllia.energie.utils;
2+
3+
import fr.euphyllia.energie.Energie;
4+
import fr.euphyllia.energie.folia.FoliaSchedulerTask;
5+
import fr.euphyllia.energie.legacy.LegacySchedulerTask;
6+
import fr.euphyllia.energie.model.*;
7+
import org.bukkit.Bukkit;
8+
import org.bukkit.Location;
9+
import org.bukkit.entity.Entity;
10+
import org.bukkit.plugin.Plugin;
11+
import org.jetbrains.annotations.NotNull;
12+
import org.jetbrains.annotations.Nullable;
13+
14+
import java.util.concurrent.TimeUnit;
15+
16+
public abstract class SchedulerTaskRunnable extends AbstractSchedulerTaskRunnable implements SchedulerRunnable {
17+
18+
@Override
19+
public void cancel() throws IllegalStateException {
20+
task.cancel();
21+
}
22+
23+
@Override
24+
public @NotNull SchedulerTaskInter runTask(@NotNull Plugin plugin, SchedulerType schedulerType) throws IllegalArgumentException, IllegalStateException {
25+
checkNotYetScheduled();
26+
if (Energie.isFolia()) {
27+
if (schedulerType.equals(SchedulerType.ASYNC)) {
28+
return setupTask(new FoliaSchedulerTask(Bukkit.getAsyncScheduler().runNow(plugin, task1 -> this.run()), false));
29+
} else {
30+
return setupTask(new FoliaSchedulerTask(Bukkit.getGlobalRegionScheduler().run(plugin, task1 -> this.run()), true));
31+
}
32+
} else {
33+
if (schedulerType.equals(SchedulerType.ASYNC)) {
34+
return setupTask(new LegacySchedulerTask(Bukkit.getScheduler().runTaskAsynchronously(plugin, this::run)));
35+
} else {
36+
return setupTask(new LegacySchedulerTask(Bukkit.getScheduler().runTask(plugin, this::run)));
37+
}
38+
}
39+
}
40+
41+
@Override
42+
public @NotNull SchedulerTaskInter runTask(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, MultipleRecords.WorldChunk worldChunk) {
43+
if (!Energie.isFolia() || schedulerType.equals(SchedulerType.ASYNC)) {
44+
return runTask(plugin, schedulerType);
45+
}
46+
checkNotYetScheduled();
47+
return setupTask(new FoliaSchedulerTask(Bukkit.getRegionScheduler().run(plugin, worldChunk.world(), worldChunk.chunkX(), worldChunk.chunkZ(), task1 -> this.run()), true));
48+
}
49+
50+
@Override
51+
public @NotNull SchedulerTaskInter runTask(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, Location location) {
52+
if (!Energie.isFolia() || schedulerType.equals(SchedulerType.ASYNC)) {
53+
return runTask(plugin, schedulerType);
54+
}
55+
checkNotYetScheduled();
56+
return setupTask(new FoliaSchedulerTask(Bukkit.getRegionScheduler().run(plugin, location, task1 -> this.run()), true));
57+
}
58+
59+
@Override
60+
public @NotNull SchedulerTaskInter runTask(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, Entity entity, @Nullable Runnable retired) {
61+
if (!Energie.isFolia() || schedulerType.equals(SchedulerType.ASYNC)) {
62+
return runTask(plugin, schedulerType);
63+
}
64+
checkNotYetScheduled();
65+
return setupTask(new FoliaSchedulerTask(entity.getScheduler().run(plugin, task1 -> this.run(), retired), true));
66+
}
67+
68+
@Override
69+
public @NotNull SchedulerTaskInter runDelayed(@NotNull Plugin plugin, SchedulerType schedulerType, long delay) throws IllegalArgumentException, IllegalStateException {
70+
checkNotYetScheduled();
71+
if (Energie.isFolia()) {
72+
if (schedulerType.equals(SchedulerType.ASYNC)) {
73+
return setupTask(new FoliaSchedulerTask(Bukkit.getAsyncScheduler().runDelayed(plugin, task1 -> this.run(), delay * 50, TimeUnit.MILLISECONDS), false));
74+
} else {
75+
return setupTask(new FoliaSchedulerTask(Bukkit.getGlobalRegionScheduler().runDelayed(plugin, task1 -> this.run(), delay), true));
76+
}
77+
} else {
78+
if (schedulerType.equals(SchedulerType.ASYNC)) {
79+
return setupTask(new LegacySchedulerTask(Bukkit.getScheduler().runTaskLaterAsynchronously(plugin, this::run, delay)));
80+
} else {
81+
return setupTask(new LegacySchedulerTask(Bukkit.getScheduler().runTaskLater(plugin, this::run, delay)));
82+
}
83+
}
84+
}
85+
86+
@Override
87+
public @NotNull SchedulerTaskInter runDelayed(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, MultipleRecords.WorldChunk worldChunk, long delayTicks) {
88+
if (!Energie.isFolia() || schedulerType.equals(SchedulerType.ASYNC)) {
89+
return runTask(plugin, schedulerType);
90+
}
91+
checkNotYetScheduled();
92+
return setupTask(new FoliaSchedulerTask(Bukkit.getRegionScheduler().runDelayed(plugin, worldChunk.world(), worldChunk.chunkX(), worldChunk.chunkZ(), task1 -> this.run(), delayTicks), true));
93+
}
94+
95+
@Override
96+
public @NotNull SchedulerTaskInter runDelayed(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, Location location, long delayTicks) {
97+
if (!Energie.isFolia() || schedulerType.equals(SchedulerType.ASYNC)) {
98+
return runTask(plugin, schedulerType);
99+
}
100+
checkNotYetScheduled();
101+
return setupTask(new FoliaSchedulerTask(Bukkit.getRegionScheduler().runDelayed(plugin, location, task1 -> this.run(), delayTicks), true));
102+
}
103+
104+
@Override
105+
public @NotNull SchedulerTaskInter runDelayed(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, Entity entity, @Nullable Runnable retired, long delayTicks) {
106+
checkNotYetScheduled();
107+
if (!Energie.isFolia() || schedulerType.equals(SchedulerType.ASYNC)) {
108+
return runTask(plugin, schedulerType);
109+
}
110+
checkNotYetScheduled();
111+
return setupTask(new FoliaSchedulerTask(entity.getScheduler().runDelayed(plugin, task1 -> this.run(), retired, delayTicks), true));
112+
}
113+
114+
@Override
115+
public @NotNull SchedulerTaskInter runAtFixedRate(@NotNull Plugin plugin, SchedulerType schedulerType, long delay, long period) throws IllegalArgumentException, IllegalStateException {
116+
checkNotYetScheduled();
117+
if (Energie.isFolia()) {
118+
if (schedulerType.equals(SchedulerType.ASYNC)) {
119+
return setupTask(new FoliaSchedulerTask(Bukkit.getAsyncScheduler().runAtFixedRate(plugin, task1 -> this.run(), delay * 50, period * 50, TimeUnit.MILLISECONDS), false));
120+
} else {
121+
return setupTask(new FoliaSchedulerTask(Bukkit.getGlobalRegionScheduler().runAtFixedRate(plugin, task1 -> this.run(), delay, period), true));
122+
}
123+
} else {
124+
if (schedulerType.equals(SchedulerType.ASYNC)) {
125+
return setupTask(new LegacySchedulerTask(Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, this::run, delay, period)));
126+
} else {
127+
return setupTask(new LegacySchedulerTask(Bukkit.getScheduler().runTaskTimer(plugin, this::run, delay, period)));
128+
}
129+
}
130+
}
131+
132+
@Override
133+
public @NotNull SchedulerTaskInter runAtFixedRate(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, MultipleRecords.WorldChunk worldChunk, long initialDelayTicks, long periodTicks) {
134+
if (!Energie.isFolia() || schedulerType.equals(SchedulerType.ASYNC)) {
135+
return runTask(plugin, schedulerType);
136+
}
137+
checkNotYetScheduled();
138+
return setupTask(new FoliaSchedulerTask(Bukkit.getRegionScheduler().runAtFixedRate(plugin, worldChunk.world(), worldChunk.chunkX(), worldChunk.chunkZ(), task1 -> this.run(), initialDelayTicks, periodTicks), true));
139+
}
140+
141+
@Override
142+
public @NotNull SchedulerTaskInter runAtFixedRate(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, Location location, long initialDelayTicks, long periodTicks) {
143+
if (!Energie.isFolia() || schedulerType.equals(SchedulerType.ASYNC)) {
144+
return runTask(plugin, schedulerType);
145+
}
146+
checkNotYetScheduled();
147+
return setupTask(new FoliaSchedulerTask(Bukkit.getRegionScheduler().runAtFixedRate(plugin, location, task1 -> this.run(), initialDelayTicks, periodTicks), true));
148+
}
149+
150+
@Override
151+
public @NotNull SchedulerTaskInter runAtFixedRate(@NotNull Plugin plugin, @NotNull SchedulerType schedulerType, Entity entity, @Nullable Runnable retired, long initialDelayTicks, long periodTicks) {
152+
checkNotYetScheduled();
153+
if (!Energie.isFolia() || schedulerType.equals(SchedulerType.ASYNC)) {
154+
return runTask(plugin, schedulerType);
155+
}
156+
checkNotYetScheduled();
157+
return setupTask(new FoliaSchedulerTask(entity.getScheduler().runAtFixedRate(plugin, task1 -> this.run(), retired, initialDelayTicks, periodTicks), true));
158+
}
159+
}

0 commit comments

Comments
 (0)