validEntitys = new ArrayList<>();
150 | for (EntityType type : EntityType.values()) {
151 | validEntitys.add(type.toString());
152 | }
153 | for (String pair : entityPairs) {
154 | String entityType = pair.split(":")[0].toUpperCase();
155 | int amount = Integer.parseInt(pair.split(":")[1]);
156 | if (validEntitys.contains(entityType)) {
157 | entityIntegerHashMap.put(entityType, amount);
158 | } else {
159 | getLogger().info(ChatColor.RED + "Unknown EntityType " + entityType + " in the EntityAmounts section of the config");
160 | }
161 | }
162 | } catch (Error | Exception throwable) {
163 | getLogger().info(ChatColor.RED + "Error in the EntityAmounts section of the config missing \":\"");
164 | }
165 | }
166 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/Metrics.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core;
2 |
3 | import com.google.gson.JsonArray;
4 | import com.google.gson.JsonObject;
5 | import com.google.gson.JsonParser;
6 | import com.google.gson.JsonPrimitive;
7 | import org.bukkit.Bukkit;
8 | import org.bukkit.configuration.file.YamlConfiguration;
9 | import org.bukkit.entity.Player;
10 | import org.bukkit.plugin.Plugin;
11 | import org.bukkit.plugin.RegisteredServiceProvider;
12 | import org.bukkit.plugin.ServicePriority;
13 |
14 | import javax.net.ssl.HttpsURLConnection;
15 | import java.io.*;
16 | import java.lang.reflect.InvocationTargetException;
17 | import java.lang.reflect.Method;
18 | import java.net.URL;
19 | import java.nio.charset.StandardCharsets;
20 | import java.util.*;
21 | import java.util.concurrent.Callable;
22 | import java.util.logging.Level;
23 | import java.util.zip.GZIPOutputStream;
24 |
25 | /**
26 | * bStats collects some data for plugin authors.
27 | *
28 | * Check out https://bStats.org/ to learn more about bStats!
29 | */
30 | @SuppressWarnings({"WeakerAccess", "unused"})
31 | public class Metrics {
32 |
33 | // The version of this bStats class
34 | public static final int B_STATS_VERSION = 1;
35 | // The url to which the data is sent
36 | private static final String URL = "https://bStats.org/submitData/bukkit";
37 | // Should failed requests be logged?
38 | private static boolean logFailedRequests;
39 | // Should the sent data be logged?
40 | private static boolean logSentData;
41 | // Should the response text be logged?
42 | private static boolean logResponseStatusText;
43 | // The uuid of the server
44 | private static String serverUUID;
45 |
46 | static {
47 | // You can use the property to disable the check in your test environment
48 | if (System.getProperty("bstats.relocatecheck") == null || !System.getProperty("bstats.relocatecheck").equals("false")) {
49 | // Maven's Relocate is clever and changes strings, too. So we have to use this little "trick" ... :D
50 | final String defaultPackage = new String(
51 | new byte[]{'o', 'r', 'g', '.', 'b', 's', 't', 'a', 't', 's', '.', 'b', 'u', 'k', 'k', 'i', 't'});
52 | final String examplePackage = new String(new byte[]{'y', 'o', 'u', 'r', '.', 'p', 'a', 'c', 'k', 'a', 'g', 'e'});
53 | // We want to make sure nobody just copy & pastes the example and use the wrong package names
54 | if (Metrics.class.getPackage().getName().equals(defaultPackage) || Metrics.class.getPackage().getName().equals(examplePackage)) {
55 | throw new IllegalStateException("bStats Metrics class has not been relocated correctly!");
56 | }
57 | }
58 | }
59 |
60 | // Is bStats enabled on this server?
61 | private final boolean enabled;
62 | // The plugin
63 | private final Plugin plugin;
64 |
65 | // The plugin id
66 | private final int pluginId;
67 |
68 | // A list with all custom charts
69 | private final List charts = new ArrayList<>();
70 |
71 | /**
72 | * Class constructor.
73 | *
74 | * @param plugin The plugin which stats should be submitted.
75 | * @param pluginId The id of the plugin.
76 | * It can be found at What is my plugin id?
77 | */
78 | public Metrics(Plugin plugin, int pluginId) {
79 | if (plugin == null) {
80 | throw new IllegalArgumentException("Plugin cannot be null!");
81 | }
82 | this.plugin = plugin;
83 | this.pluginId = pluginId;
84 |
85 | // Get the config file
86 | File bStatsFolder = new File(plugin.getDataFolder().getParentFile(), "bStats");
87 | File configFile = new File(bStatsFolder, "config.yml");
88 | YamlConfiguration config = YamlConfiguration.loadConfiguration(configFile);
89 |
90 | // Check if the config file exists
91 | if (!config.isSet("serverUuid")) {
92 |
93 | // Add default values
94 | config.addDefault("enabled", true);
95 | // Every server gets it's unique random id.
96 | config.addDefault("serverUuid", UUID.randomUUID().toString());
97 | // Should failed request be logged?
98 | config.addDefault("logFailedRequests", false);
99 | // Should the sent data be logged?
100 | config.addDefault("logSentData", false);
101 | // Should the response text be logged?
102 | config.addDefault("logResponseStatusText", false);
103 |
104 | // Inform the server owners about bStats
105 | config.options().header(
106 | "bStats collects some data for plugin authors like how many servers are using their plugins.\n" +
107 | "To honor their work, you should not disable it.\n" +
108 | "This has nearly no effect on the server performance!\n" +
109 | "Check out https://bStats.org/ to learn more :)"
110 | ).copyDefaults(true);
111 | try {
112 | config.save(configFile);
113 | } catch (IOException ignored) {
114 | }
115 | }
116 |
117 | // Load the data
118 | enabled = config.getBoolean("enabled", true);
119 | serverUUID = config.getString("serverUuid");
120 | logFailedRequests = config.getBoolean("logFailedRequests", false);
121 | logSentData = config.getBoolean("logSentData", false);
122 | logResponseStatusText = config.getBoolean("logResponseStatusText", false);
123 |
124 | if (enabled) {
125 | boolean found = false;
126 | // Search for all other bStats Metrics classes to see if we are the first one
127 | for (Class service : Bukkit.getServicesManager().getKnownServices()) {
128 | try {
129 | service.getField("B_STATS_VERSION"); // Our identifier :)
130 | found = true; // We aren't the first
131 | break;
132 | } catch (NoSuchFieldException ignored) {
133 | }
134 | }
135 | // Register our service
136 | Bukkit.getServicesManager().register(Metrics.class, this, plugin, ServicePriority.Normal);
137 | if (!found) {
138 | // We are the first!
139 | startSubmitting();
140 | }
141 | }
142 | }
143 |
144 | /**
145 | * Sends the data to the bStats server.
146 | *
147 | * @param plugin Any plugin. It's just used to get a logger instance.
148 | * @param data The data to send.
149 | * @throws Exception If the request failed.
150 | */
151 | private static void sendData(Plugin plugin, JsonObject data) throws Exception {
152 | if (data == null) {
153 | throw new IllegalArgumentException("Data cannot be null!");
154 | }
155 | if (Bukkit.isPrimaryThread()) {
156 | throw new IllegalAccessException("This method must not be called from the main thread!");
157 | }
158 | if (logSentData) {
159 | plugin.getLogger().info("Sending data to bStats: " + data);
160 | }
161 | HttpsURLConnection connection = (HttpsURLConnection) new URL(URL).openConnection();
162 |
163 | // Compress the data to save bandwidth
164 | byte[] compressedData = compress(data.toString());
165 |
166 | // Add headers
167 | connection.setRequestMethod("POST");
168 | connection.addRequestProperty("Accept", "application/json");
169 | connection.addRequestProperty("Connection", "close");
170 | connection.addRequestProperty("Content-Encoding", "gzip"); // We gzip our request
171 | connection.addRequestProperty("Content-Length", String.valueOf(compressedData.length));
172 | connection.setRequestProperty("Content-Type", "application/json"); // We send our data in JSON format
173 | connection.setRequestProperty("User-Agent", "MC-Server/" + B_STATS_VERSION);
174 |
175 | // Send data
176 | connection.setDoOutput(true);
177 | try (DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream())) {
178 | outputStream.write(compressedData);
179 | }
180 |
181 | StringBuilder builder = new StringBuilder();
182 | try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
183 | String line;
184 | while ((line = bufferedReader.readLine()) != null) {
185 | builder.append(line);
186 | }
187 | }
188 |
189 | if (logResponseStatusText) {
190 | plugin.getLogger().info("Sent data to bStats and received response: " + builder);
191 | }
192 | }
193 |
194 | /**
195 | * Gzips the given String.
196 | *
197 | * @param str The string to gzip.
198 | * @return The gzipped String.
199 | * @throws IOException If the compression failed.
200 | */
201 | private static byte[] compress(final String str) throws IOException {
202 | if (str == null) {
203 | return null;
204 | }
205 | ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
206 | try (GZIPOutputStream gzip = new GZIPOutputStream(outputStream)) {
207 | gzip.write(str.getBytes(StandardCharsets.UTF_8));
208 | }
209 | return outputStream.toByteArray();
210 | }
211 |
212 | /**
213 | * Checks if bStats is enabled.
214 | *
215 | * @return Whether bStats is enabled or not.
216 | */
217 | public boolean isEnabled() {
218 | return enabled;
219 | }
220 |
221 | /**
222 | * Adds a custom chart.
223 | *
224 | * @param chart The chart to add.
225 | */
226 | public void addCustomChart(CustomChart chart) {
227 | if (chart == null) {
228 | throw new IllegalArgumentException("Chart cannot be null!");
229 | }
230 | charts.add(chart);
231 | }
232 |
233 | /**
234 | * Starts the Scheduler which submits our data every 30 minutes.
235 | */
236 | private void startSubmitting() {
237 | final Timer timer = new Timer(true); // We use a timer cause the Bukkit scheduler is affected by server lags
238 | timer.scheduleAtFixedRate(new TimerTask() {
239 | @Override
240 | public void run() {
241 | if (!plugin.isEnabled()) { // Plugin was disabled
242 | timer.cancel();
243 | return;
244 | }
245 | // Nevertheless we want our code to run in the Bukkit main thread, so we have to use the Bukkit scheduler
246 | // Don't be afraid! The connection to the bStats server is still async, only the stats collection is sync ;)
247 | Bukkit.getScheduler().runTask(plugin, () -> submitData());
248 | }
249 | }, 1000 * 60 * 5, 1000 * 60 * 30);
250 | // Submit the data every 30 minutes, first time after 5 minutes to give other plugins enough time to start
251 | // WARNING: Changing the frequency has no effect but your plugin WILL be blocked/deleted!
252 | // WARNING: Just don't do it!
253 | }
254 |
255 | /**
256 | * Gets the plugin specific data.
257 | * This method is called using Reflection.
258 | *
259 | * @return The plugin specific data.
260 | */
261 | public JsonObject getPluginData() {
262 | JsonObject data = new JsonObject();
263 |
264 | String pluginName = plugin.getDescription().getName();
265 | String pluginVersion = plugin.getDescription().getVersion();
266 |
267 | data.addProperty("pluginName", pluginName); // Append the name of the plugin
268 | data.addProperty("id", pluginId); // Append the id of the plugin
269 | data.addProperty("pluginVersion", pluginVersion); // Append the version of the plugin
270 | JsonArray customCharts = new JsonArray();
271 | for (CustomChart customChart : charts) {
272 | // Add the data of the custom charts
273 | JsonObject chart = customChart.getRequestJsonObject();
274 | if (chart == null) { // If the chart is null, we skip it
275 | continue;
276 | }
277 | customCharts.add(chart);
278 | }
279 | data.add("customCharts", customCharts);
280 |
281 | return data;
282 | }
283 |
284 | /**
285 | * Gets the server specific data.
286 | *
287 | * @return The server specific data.
288 | */
289 | private JsonObject getServerData() {
290 | // Minecraft specific data
291 | int playerAmount;
292 | try {
293 | // Around MC 1.8 the return type was changed to a collection from an array,
294 | // This fixes java.lang.NoSuchMethodError: org.bukkit.Bukkit.getOnlinePlayers()Ljava/util/Collection;
295 | Method onlinePlayersMethod = Class.forName("org.bukkit.Server").getMethod("getOnlinePlayers");
296 | playerAmount = onlinePlayersMethod.getReturnType().equals(Collection.class)
297 | ? ((Collection) onlinePlayersMethod.invoke(Bukkit.getServer())).size()
298 | : ((Player[]) onlinePlayersMethod.invoke(Bukkit.getServer())).length;
299 | } catch (Exception e) {
300 | playerAmount = Bukkit.getOnlinePlayers().size(); // Just use the new method if the Reflection failed
301 | }
302 | int onlineMode = Bukkit.getOnlineMode() ? 1 : 0;
303 | String bukkitVersion = Bukkit.getVersion();
304 | String bukkitName = Bukkit.getName();
305 |
306 | // OS/Java specific data
307 | String javaVersion = System.getProperty("java.version");
308 | String osName = System.getProperty("os.name");
309 | String osArch = System.getProperty("os.arch");
310 | String osVersion = System.getProperty("os.version");
311 | int coreCount = Runtime.getRuntime().availableProcessors();
312 |
313 | JsonObject data = new JsonObject();
314 |
315 | data.addProperty("serverUUID", serverUUID);
316 |
317 | data.addProperty("playerAmount", playerAmount);
318 | data.addProperty("onlineMode", onlineMode);
319 | data.addProperty("bukkitVersion", bukkitVersion);
320 | data.addProperty("bukkitName", bukkitName);
321 |
322 | data.addProperty("javaVersion", javaVersion);
323 | data.addProperty("osName", osName);
324 | data.addProperty("osArch", osArch);
325 | data.addProperty("osVersion", osVersion);
326 | data.addProperty("coreCount", coreCount);
327 |
328 | return data;
329 | }
330 |
331 | /**
332 | * Collects the data and sends it afterwards.
333 | */
334 | private void submitData() {
335 | final JsonObject data = getServerData();
336 |
337 | JsonArray pluginData = new JsonArray();
338 | // Search for all other bStats Metrics classes to get their plugin data
339 | for (Class service : Bukkit.getServicesManager().getKnownServices()) {
340 | try {
341 | service.getField("B_STATS_VERSION"); // Our identifier :)
342 |
343 | for (RegisteredServiceProvider provider : Bukkit.getServicesManager().getRegistrations(service)) {
344 | try {
345 | Object plugin = provider.getService().getMethod("getPluginData").invoke(provider.getProvider());
346 | if (plugin instanceof JsonObject) {
347 | pluginData.add((JsonObject) plugin);
348 | } else { // old bstats version compatibility
349 | try {
350 | Class jsonObjectJsonSimple = Class.forName("org.json.simple.JSONObject");
351 | if (plugin.getClass().isAssignableFrom(jsonObjectJsonSimple)) {
352 | Method jsonStringGetter = jsonObjectJsonSimple.getDeclaredMethod("toJSONString");
353 | jsonStringGetter.setAccessible(true);
354 | String jsonString = (String) jsonStringGetter.invoke(plugin);
355 | JsonObject object = new JsonParser().parse(jsonString).getAsJsonObject();
356 | pluginData.add(object);
357 | }
358 | } catch (ClassNotFoundException e) {
359 | // minecraft version 1.14+
360 | if (logFailedRequests) {
361 | this.plugin.getLogger().log(Level.SEVERE, "Encountered unexpected exception", e);
362 | }
363 | }
364 | }
365 | } catch (NullPointerException | NoSuchMethodException | IllegalAccessException | InvocationTargetException ignored) {
366 | }
367 | }
368 | } catch (NoSuchFieldException ignored) {
369 | }
370 | }
371 |
372 | data.add("plugins", pluginData);
373 |
374 | // Create a new thread for the connection to the bStats server
375 | new Thread(() -> {
376 | try {
377 | // Send the data
378 | sendData(plugin, data);
379 | } catch (Exception e) {
380 | // Something went wrong! :(
381 | if (logFailedRequests) {
382 | plugin.getLogger().log(Level.WARNING, "Could not submit plugin stats of " + plugin.getName(), e);
383 | }
384 | }
385 | }).start();
386 | }
387 |
388 | /**
389 | * Represents a custom chart.
390 | */
391 | public static abstract class CustomChart {
392 |
393 | // The id of the chart
394 | final String chartId;
395 |
396 | /**
397 | * Class constructor.
398 | *
399 | * @param chartId The id of the chart.
400 | */
401 | CustomChart(String chartId) {
402 | if (chartId == null || chartId.isEmpty()) {
403 | throw new IllegalArgumentException("ChartId cannot be null or empty!");
404 | }
405 | this.chartId = chartId;
406 | }
407 |
408 | private JsonObject getRequestJsonObject() {
409 | JsonObject chart = new JsonObject();
410 | chart.addProperty("chartId", chartId);
411 | try {
412 | JsonObject data = getChartData();
413 | if (data == null) {
414 | // If the data is null we don't send the chart.
415 | return null;
416 | }
417 | chart.add("data", data);
418 | } catch (Throwable t) {
419 | if (logFailedRequests) {
420 | Bukkit.getLogger().log(Level.WARNING, "Failed to get data for custom chart with id " + chartId, t);
421 | }
422 | return null;
423 | }
424 | return chart;
425 | }
426 |
427 | protected abstract JsonObject getChartData() throws Exception;
428 |
429 | }
430 |
431 | /**
432 | * Represents a custom simple pie.
433 | */
434 | public static class SimplePie extends CustomChart {
435 |
436 | private final Callable callable;
437 |
438 | /**
439 | * Class constructor.
440 | *
441 | * @param chartId The id of the chart.
442 | * @param callable The callable which is used to request the chart data.
443 | */
444 | public SimplePie(String chartId, Callable callable) {
445 | super(chartId);
446 | this.callable = callable;
447 | }
448 |
449 | @Override
450 | protected JsonObject getChartData() throws Exception {
451 | JsonObject data = new JsonObject();
452 | String value = callable.call();
453 | if (value == null || value.isEmpty()) {
454 | // Null = skip the chart
455 | return null;
456 | }
457 | data.addProperty("value", value);
458 | return data;
459 | }
460 | }
461 |
462 | /**
463 | * Represents a custom advanced pie.
464 | */
465 | public static class AdvancedPie extends CustomChart {
466 |
467 | private final Callable> callable;
468 |
469 | /**
470 | * Class constructor.
471 | *
472 | * @param chartId The id of the chart.
473 | * @param callable The callable which is used to request the chart data.
474 | */
475 | public AdvancedPie(String chartId, Callable> callable) {
476 | super(chartId);
477 | this.callable = callable;
478 | }
479 |
480 | @Override
481 | protected JsonObject getChartData() throws Exception {
482 | JsonObject data = new JsonObject();
483 | JsonObject values = new JsonObject();
484 | Map map = callable.call();
485 | if (map == null || map.isEmpty()) {
486 | // Null = skip the chart
487 | return null;
488 | }
489 | boolean allSkipped = true;
490 | for (Map.Entry entry : map.entrySet()) {
491 | if (entry.getValue() == 0) {
492 | continue; // Skip this invalid
493 | }
494 | allSkipped = false;
495 | values.addProperty(entry.getKey(), entry.getValue());
496 | }
497 | if (allSkipped) {
498 | // Null = skip the chart
499 | return null;
500 | }
501 | data.add("values", values);
502 | return data;
503 | }
504 | }
505 |
506 | /**
507 | * Represents a custom drilldown pie.
508 | */
509 | public static class DrilldownPie extends CustomChart {
510 |
511 | private final Callable>> callable;
512 |
513 | /**
514 | * Class constructor.
515 | *
516 | * @param chartId The id of the chart.
517 | * @param callable The callable which is used to request the chart data.
518 | */
519 | public DrilldownPie(String chartId, Callable>> callable) {
520 | super(chartId);
521 | this.callable = callable;
522 | }
523 |
524 | @Override
525 | public JsonObject getChartData() throws Exception {
526 | JsonObject data = new JsonObject();
527 | JsonObject values = new JsonObject();
528 | Map> map = callable.call();
529 | if (map == null || map.isEmpty()) {
530 | // Null = skip the chart
531 | return null;
532 | }
533 | boolean reallyAllSkipped = true;
534 | for (Map.Entry> entryValues : map.entrySet()) {
535 | JsonObject value = new JsonObject();
536 | boolean allSkipped = true;
537 | for (Map.Entry valueEntry : map.get(entryValues.getKey()).entrySet()) {
538 | value.addProperty(valueEntry.getKey(), valueEntry.getValue());
539 | allSkipped = false;
540 | }
541 | if (!allSkipped) {
542 | reallyAllSkipped = false;
543 | values.add(entryValues.getKey(), value);
544 | }
545 | }
546 | if (reallyAllSkipped) {
547 | // Null = skip the chart
548 | return null;
549 | }
550 | data.add("values", values);
551 | return data;
552 | }
553 | }
554 |
555 | /**
556 | * Represents a custom single line chart.
557 | */
558 | public static class SingleLineChart extends CustomChart {
559 |
560 | private final Callable callable;
561 |
562 | /**
563 | * Class constructor.
564 | *
565 | * @param chartId The id of the chart.
566 | * @param callable The callable which is used to request the chart data.
567 | */
568 | public SingleLineChart(String chartId, Callable callable) {
569 | super(chartId);
570 | this.callable = callable;
571 | }
572 |
573 | @Override
574 | protected JsonObject getChartData() throws Exception {
575 | JsonObject data = new JsonObject();
576 | int value = callable.call();
577 | if (value == 0) {
578 | // Null = skip the chart
579 | return null;
580 | }
581 | data.addProperty("value", value);
582 | return data;
583 | }
584 |
585 | }
586 |
587 | /**
588 | * Represents a custom multi line chart.
589 | */
590 | public static class MultiLineChart extends CustomChart {
591 |
592 | private final Callable> callable;
593 |
594 | /**
595 | * Class constructor.
596 | *
597 | * @param chartId The id of the chart.
598 | * @param callable The callable which is used to request the chart data.
599 | */
600 | public MultiLineChart(String chartId, Callable> callable) {
601 | super(chartId);
602 | this.callable = callable;
603 | }
604 |
605 | @Override
606 | protected JsonObject getChartData() throws Exception {
607 | JsonObject data = new JsonObject();
608 | JsonObject values = new JsonObject();
609 | Map map = callable.call();
610 | if (map == null || map.isEmpty()) {
611 | // Null = skip the chart
612 | return null;
613 | }
614 | boolean allSkipped = true;
615 | for (Map.Entry entry : map.entrySet()) {
616 | if (entry.getValue() == 0) {
617 | continue; // Skip this invalid
618 | }
619 | allSkipped = false;
620 | values.addProperty(entry.getKey(), entry.getValue());
621 | }
622 | if (allSkipped) {
623 | // Null = skip the chart
624 | return null;
625 | }
626 | data.add("values", values);
627 | return data;
628 | }
629 |
630 | }
631 |
632 | /**
633 | * Represents a custom simple bar chart.
634 | */
635 | public static class SimpleBarChart extends CustomChart {
636 |
637 | private final Callable> callable;
638 |
639 | /**
640 | * Class constructor.
641 | *
642 | * @param chartId The id of the chart.
643 | * @param callable The callable which is used to request the chart data.
644 | */
645 | public SimpleBarChart(String chartId, Callable> callable) {
646 | super(chartId);
647 | this.callable = callable;
648 | }
649 |
650 | @Override
651 | protected JsonObject getChartData() throws Exception {
652 | JsonObject data = new JsonObject();
653 | JsonObject values = new JsonObject();
654 | Map map = callable.call();
655 | if (map == null || map.isEmpty()) {
656 | // Null = skip the chart
657 | return null;
658 | }
659 | for (Map.Entry entry : map.entrySet()) {
660 | JsonArray categoryValues = new JsonArray();
661 | categoryValues.add(new JsonPrimitive(entry.getValue()));
662 | values.add(entry.getKey(), categoryValues);
663 | }
664 | data.add("values", values);
665 | return data;
666 | }
667 |
668 | }
669 |
670 | /**
671 | * Represents a custom advanced bar chart.
672 | */
673 | public static class AdvancedBarChart extends CustomChart {
674 |
675 | private final Callable> callable;
676 |
677 | /**
678 | * Class constructor.
679 | *
680 | * @param chartId The id of the chart.
681 | * @param callable The callable which is used to request the chart data.
682 | */
683 | public AdvancedBarChart(String chartId, Callable> callable) {
684 | super(chartId);
685 | this.callable = callable;
686 | }
687 |
688 | @Override
689 | protected JsonObject getChartData() throws Exception {
690 | JsonObject data = new JsonObject();
691 | JsonObject values = new JsonObject();
692 | Map map = callable.call();
693 | if (map == null || map.isEmpty()) {
694 | // Null = skip the chart
695 | return null;
696 | }
697 | boolean allSkipped = true;
698 | for (Map.Entry entry : map.entrySet()) {
699 | if (entry.getValue().length == 0) {
700 | continue; // Skip this invalid
701 | }
702 | allSkipped = false;
703 | JsonArray categoryValues = new JsonArray();
704 | for (int categoryValue : entry.getValue()) {
705 | categoryValues.add(new JsonPrimitive(categoryValue));
706 | }
707 | values.add(entry.getKey(), categoryValues);
708 | }
709 | if (allSkipped) {
710 | // Null = skip the chart
711 | return null;
712 | }
713 | data.add("values", values);
714 | return data;
715 | }
716 | }
717 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/command/BaseCommand.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.command;
2 |
3 | import org.bukkit.ChatColor;
4 | import org.bukkit.command.CommandSender;
5 | import org.bukkit.entity.Player;
6 | import org.l2x9.l2x9core.Main;
7 |
8 | public abstract class BaseCommand {
9 | public final String CONSOLE_ONLY = "This command is console only";
10 | public final String PLAYER_ONLY = "This command is player only";
11 | private final String name;
12 | private final String usage;
13 | private final String permission;
14 | private String description;
15 | private String[] subCommands;
16 |
17 | public BaseCommand(String name, String usage, String permission) {
18 | this.name = name;
19 | this.usage = usage;
20 | this.permission = permission;
21 | }
22 | public BaseCommand(String name, String usage, String permission, String description) {
23 | this.name = name;
24 | this.usage = usage;
25 | this.permission = permission;
26 | this.description = description;
27 | }
28 |
29 | public BaseCommand(String name, String usage, String permission, String description, String[] subCommands) {
30 | this.name = name;
31 | this.usage = usage;
32 | this.permission = permission;
33 | this.description = description;
34 | this.subCommands = subCommands;
35 | }
36 |
37 | public String getName() {
38 | return name;
39 | }
40 |
41 | public String getUsage() {
42 | return usage;
43 | }
44 |
45 | public String getPermission() {
46 | return permission;
47 | }
48 |
49 | public String getDescription() {
50 | return description;
51 | }
52 |
53 | public String[] getSubCommands() {
54 | return subCommands;
55 | }
56 | public void sendMessage(CommandSender sender, String message) {
57 | sender.sendMessage(ChatColor.translateAlternateColorCodes('&', message));
58 | }
59 |
60 | public void sendNoPermission(CommandSender sender) {
61 | sender.sendMessage(ChatColor.translateAlternateColorCodes(
62 | '&',
63 | "&4Error:&r&c You are lacking the permission " + getPermission()));
64 | }
65 |
66 | public void sendErrorMessage(CommandSender sender, String message) {
67 | String finalMessage = "&4Error:&r&c " + message;
68 | finalMessage = ChatColor.translateAlternateColorCodes('&', finalMessage);
69 | sender.sendMessage(finalMessage);
70 | }
71 |
72 | public Player getSenderAsPlayer(CommandSender sender) {
73 | if (sender instanceof Player) {
74 | return (Player) sender;
75 | } else {
76 | return null;
77 | }
78 | }
79 | public abstract void execute(CommandSender sender, String[] args, Main plugin);
80 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/command/BaseTabCommand.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.command;
2 |
3 | import java.util.List;
4 |
5 | public abstract class BaseTabCommand extends BaseCommand {
6 | private List tabCompletions;
7 |
8 | public BaseTabCommand(String name, String usage, String permission) {
9 | super(name, usage, permission);
10 | }
11 |
12 | public BaseTabCommand(String name, String usage, String permission, String description) {
13 | super(name, usage, permission, description);
14 | }
15 | public BaseTabCommand(String name, String usage, String permission, String description, String[] subCommands) {
16 | super(name, usage, permission, description, subCommands);
17 | }
18 |
19 | public abstract List onTab(String[] args);
20 |
21 | public List getTabCompletions() {
22 | return tabCompletions;
23 | }
24 |
25 | public void setTabCompletions(List tabCompletions) {
26 | this.tabCompletions = tabCompletions;
27 | }
28 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/command/CommandHandler.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.command;
2 |
3 | import org.bukkit.Bukkit;
4 | import org.bukkit.command.Command;
5 | import org.bukkit.command.CommandException;
6 | import org.bukkit.command.CommandSender;
7 | import org.bukkit.command.TabExecutor;
8 | import org.bukkit.entity.Player;
9 | import org.l2x9.l2x9core.Main;
10 | import org.l2x9.l2x9core.command.commands.*;
11 |
12 | import java.util.ArrayList;
13 | import java.util.Collections;
14 | import java.util.List;
15 |
16 | public class CommandHandler implements TabExecutor {
17 | private final ArrayList commands = new ArrayList<>();
18 | private final Main plugin;
19 |
20 | public CommandHandler(Main plugin) {
21 | this.plugin = plugin;
22 | }
23 |
24 | public void registerCommands() throws NotInPluginYMLException {
25 | try {
26 | addCommand(new org.l2x9.l2x9core.command.commands.BaseCommand());
27 | addCommand(new DiscordCommand());
28 | if (plugin.getConfigBoolean("Help.Enabled")) {
29 | addCommand(new HelpCommand());
30 | }
31 | addCommand(new OpenInv());
32 | addCommand(new SayCommand());
33 | addCommand(new SpawnCommand());
34 | addCommand(new SpeedCommand());
35 | addCommand(new UptimeCommand());
36 | addCommand(new UUidCommand());
37 | addCommand(new WorldSwitcher());
38 | } catch (Exception e) {
39 | throw new NotInPluginYMLException("Command not in plugin.yml");
40 | }
41 | }
42 |
43 | private void addCommand(BaseCommand command) {
44 | commands.add(command);
45 | plugin.getCommand(command.getName()).setExecutor(this);
46 | }
47 |
48 | @Override
49 | public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
50 | for (BaseCommand command : commands) {
51 | if (command.getName().equalsIgnoreCase(cmd.getName())) {
52 | if (sender.hasPermission(command.getPermission())) {
53 | command.execute(sender, args, plugin);
54 | } else {
55 | command.sendNoPermission(sender);
56 | }
57 | break;
58 | }
59 | }
60 | return true;
61 | }
62 |
63 | @Override
64 | public List onTabComplete(CommandSender sender, Command cmd, String alias, String[] args) {
65 | for (BaseCommand command : commands) {
66 | if (command.getName().equalsIgnoreCase(cmd.getName())) {
67 | if (command instanceof BaseTabCommand) {
68 | BaseTabCommand tabCommand = (BaseTabCommand) command;
69 | return tabCommand.onTab(args);
70 | } else {
71 | List players = new ArrayList<>();
72 | for (Player player : Bukkit.getOnlinePlayers()) {
73 | players.add(player.getName());
74 | }
75 | return players;
76 | }
77 | }
78 | }
79 | return Collections.singletonList("Not a tab command");
80 | }
81 |
82 | public ArrayList getCommands() {
83 | return commands;
84 | }
85 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/command/NotInPluginYMLException.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.command;
2 |
3 | public class NotInPluginYMLException extends Exception {
4 |
5 | public NotInPluginYMLException(String message) {
6 | super(message);
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/command/commands/BaseCommand.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.command.commands;
2 |
3 | import org.bukkit.command.CommandSender;
4 | import org.l2x9.l2x9core.Main;
5 | import org.l2x9.l2x9core.util.Utils;
6 |
7 | public class BaseCommand extends org.l2x9.l2x9core.command.BaseCommand {
8 |
9 | public BaseCommand() {
10 | super(
11 | "lef",
12 | "/lef reload | version | help",
13 | "l2x9core.command.aef",
14 | "Base command of the plugin",
15 | new String[]{
16 | "reload::Reload the config file",
17 | "version::Show the version of the plugin",
18 | "help::Shows the help for the plugin"
19 | }
20 | );
21 | }
22 |
23 | @Override
24 | public void execute(CommandSender sender, String[] args, Main plugin) {
25 | if (args.length > 0) {
26 | switch (args[0]) {
27 | case "reload":
28 | plugin.reloadConfig();
29 | plugin.setupChunkEntityLimit();
30 | Utils.sendMessage(sender, Utils.getPrefix() + "&aReloaded configuration file");
31 | break;
32 | case "version":
33 | sendMessage(sender, Utils.getPrefix() + "&6Version &r&c" + plugin.getDescription().getVersion());
34 | break;
35 | case "help":
36 | sendMessage(sender, Utils.getPrefix() + "&1---&r " + Utils.getPrefix() + "&6Help &r&1---");
37 | sendMessage(sender, Utils.getPrefix() + "");
38 | plugin.getCommandHandler().getCommands().forEach(command -> {
39 | String helpMsg = "&1---&r&3&l /" + command.getName() + "&r&6 Help &r&1---";
40 | sendMessage(sender, Utils.getPrefix() + helpMsg);
41 | sendMessage(sender, Utils.getPrefix() + "&3Description: " + command.getDescription());
42 | if (command.getSubCommands() != null) {
43 | if (command.getSubCommands().length > 0) {
44 | sendMessage(sender, Utils.getPrefix() + helpMsg.replace("Help", "Subcommands"));
45 | for (String subCommand : command.getSubCommands()) {
46 | String[] split = subCommand.split("::");
47 | if (split.length > 0) {
48 | sendMessage(sender, Utils.getPrefix() + "&6 /" + command.getName() + " " + split[0] + " |&r&e " + split[1]);
49 | } else {
50 | sendMessage(sender, Utils.getPrefix() + "&6 /" + command.getName() + " " + subCommand);
51 | }
52 | }
53 | sendMessage(sender, Utils.getPrefix() + "&1--------------------");
54 | }
55 | }
56 | sendMessage(sender, Utils.getPrefix() + "");
57 | });
58 | break;
59 | }
60 | } else {
61 | sendErrorMessage(sender, getUsage());
62 | }
63 | }
64 | }
65 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/command/commands/CrashCommand.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.command.commands;
2 |
3 | import org.bukkit.Bukkit;
4 | import org.bukkit.command.CommandSender;
5 | import org.bukkit.entity.Player;
6 | import org.l2x9.l2x9core.Main;
7 | import org.l2x9.l2x9core.command.BaseCommand;
8 | import org.l2x9.l2x9core.util.Utils;
9 |
10 | public class CrashCommand extends BaseCommand {
11 |
12 | public CrashCommand() {
13 | super(
14 | "crash",
15 | "/crash | nearby | everyone | elytra | taco",
16 | "l2x9core.command.crash",
17 | "Crash players games",
18 | new String[] {
19 | "elytra::Crash the games of everyone who is using an elytra",
20 | "everyone::Crash the game of everyone on the server",
21 | "nearby::Crash everyone within a radius",
22 | "taco::Crash the game of everyone with their game set to a spanish language"
23 | });
24 | }
25 |
26 | @Override
27 | public void execute(CommandSender sender, String[] args, Main plugin) {
28 | if (args.length == 0) {
29 | sendErrorMessage(sender, getUsage());
30 | } else {
31 | switch (args[0]) {
32 | case "elytra":
33 | for (Player online : Bukkit.getOnlinePlayers()) {
34 | if (!online.isOp()) {
35 | if (online.isGliding()) {
36 | Utils.crashPlayer(online);
37 | sendMessage(sender, "&6You have just crashed&r&c " + online.getName());
38 |
39 | }
40 | }
41 | }
42 | break;
43 | case "everyone":
44 | for (Player online : Bukkit.getOnlinePlayers()) {
45 | if (!online.isOp()) {
46 | Utils.crashPlayer(online);
47 | sendMessage(sender, "&6You have just crashed&r&c " + online.getName());
48 | }
49 | }
50 | break;
51 | case "nearby":
52 | try {
53 | Player player = getSenderAsPlayer(sender);
54 | if (player != null) {
55 | for (Player nearby : player.getLocation().getNearbyPlayers(Integer.parseInt(args[1]))) {
56 | if (!nearby.hasPermission(getPermission())) {
57 | Utils.crashPlayer(nearby);
58 | sendMessage(player, "&6You have just crashed&r&c " + nearby.getName());
59 | }
60 | }
61 | } else {
62 | sendErrorMessage(sender, PLAYER_ONLY);
63 | break;
64 | }
65 | } catch (NumberFormatException | ArrayIndexOutOfBoundsException e) {
66 | sendMessage(sender, "The second argument must be a number");
67 | }
68 | break;
69 | case "taco":
70 | for (Player online : Bukkit.getOnlinePlayers()) {
71 | if (online.getLocale().toLowerCase().contains("es")) {
72 | Utils.crashPlayer(online);
73 | sendMessage(sender, "&6You have just crashed&r&c " + online.getName());
74 | }
75 | }
76 | break;
77 | default:
78 | Player target = Bukkit.getPlayer(args[0]);
79 | if (Bukkit.getOnlinePlayers().contains(target)) {
80 | if (!target.hasPermission(getPermission())) {
81 | Utils.crashPlayer(target);
82 | sendMessage(sender, "&6You have just crashed&r&c " + target.getName());
83 | } else {
84 | sendErrorMessage(sender, "You cannot crash that player");
85 | }
86 | } else {
87 | sendErrorMessage(sender, "Target not online");
88 | }
89 | break;
90 | }
91 | }
92 | }
93 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/command/commands/DiscordCommand.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.command.commands;
2 |
3 | import org.bukkit.command.CommandSender;
4 | import org.l2x9.l2x9core.Main;
5 | import org.l2x9.l2x9core.command.BaseCommand;
6 |
7 | public class DiscordCommand extends BaseCommand {
8 |
9 | public DiscordCommand() {
10 | super(
11 | "discord",
12 | "/discord",
13 | "l2x9core.command.discord",
14 | "Shows a discord link");
15 | }
16 |
17 | @Override
18 | public void execute(CommandSender sender, String[] args, Main plugin) {
19 | sendMessage(sender, plugin.getConfig().getString("Discord"));
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/command/commands/HelpCommand.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.command.commands;
2 |
3 | import org.bukkit.command.CommandSender;
4 | import org.l2x9.l2x9core.Main;
5 | import org.l2x9.l2x9core.command.BaseCommand;
6 | import org.l2x9.l2x9core.util.Utils;
7 |
8 | import java.util.List;
9 |
10 | public class HelpCommand extends BaseCommand {
11 | public HelpCommand() {
12 | super(
13 | "help",
14 | "/help",
15 | "l2x9core.command.help",
16 | "Displays a custom help menu");
17 | }
18 |
19 | @Override
20 | public void execute(CommandSender sender, String[] args, Main plugin) {
21 | List list = plugin.getConfig().getStringList("Help.List");
22 | String join = String.join("\n", list);
23 | Utils.sendMessage(sender, join);
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/command/commands/OpenInv.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.command.commands;
2 |
3 |
4 | import org.bukkit.Bukkit;
5 | import org.bukkit.command.CommandSender;
6 | import org.bukkit.entity.Player;
7 | import org.l2x9.l2x9core.Main;
8 | import org.l2x9.l2x9core.command.BaseCommand;
9 |
10 | public class OpenInv extends BaseCommand {
11 | public OpenInv() {
12 | super(
13 | "open",
14 | "/open ",
15 | "l2x9core.command.openinv",
16 | "Open peoples inventories",
17 | new String[]{
18 | "inventory::Open the inventory of the specified player",
19 | "ender::Open the ender chest of the specified player"
20 | }
21 | );
22 | }
23 |
24 | @Override
25 | public void execute(CommandSender sender, String[] args, Main plugin) {
26 | Player player = getSenderAsPlayer(sender);
27 | if (player != null) {
28 | if (args.length < 2) {
29 | sendErrorMessage(sender, getUsage());
30 | } else {
31 | Player target = Bukkit.getPlayer(args[1]);
32 | if (target.isOnline()) {
33 | switch (args[0]) {
34 | case "ender":
35 | player.openInventory(target.getEnderChest());
36 | break;
37 | case "inv":
38 | case "inventory":
39 | player.openInventory(target.getInventory());
40 | break;
41 | default:
42 | sendErrorMessage(sender, "Unknown argument " + args[0]);
43 | }
44 | } else {
45 | sendErrorMessage(sender, "Player " + args[0] + " not online");
46 | }
47 | }
48 | } else {
49 | sendErrorMessage(sender, PLAYER_ONLY);
50 | }
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/command/commands/SayCommand.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.command.commands;
2 |
3 | import org.bukkit.Bukkit;
4 | import org.bukkit.ChatColor;
5 | import org.bukkit.command.CommandSender;
6 | import org.l2x9.l2x9core.Main;
7 | import org.l2x9.l2x9core.command.BaseCommand;
8 |
9 | public class SayCommand extends BaseCommand {
10 |
11 | public SayCommand() {
12 | super(
13 | "say",
14 | "/say ",
15 | "l2x9core.command.say",
16 | "Configurable say command");
17 | }
18 |
19 | @Override
20 | public void execute(CommandSender sender, String[] args, Main plugin) {
21 | if (args.length > 0) {
22 | String configMessage = plugin.getConfig().getString("SayCommandFormat");
23 | StringBuilder builder = new StringBuilder();
24 | for (String arg : args) {
25 | builder.append(arg.concat(" "));
26 | }
27 | Bukkit.getServer().broadcastMessage(
28 | ChatColor.translateAlternateColorCodes(
29 | '&',
30 | configMessage.replace("{message}", builder.toString())));
31 | } else {
32 | sendErrorMessage(sender, "Message cannot be blank");
33 | }
34 | }
35 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/command/commands/SpawnCommand.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.command.commands;
2 |
3 | import org.bukkit.command.CommandSender;
4 | import org.bukkit.entity.EntityType;
5 | import org.bukkit.entity.Player;
6 | import org.l2x9.l2x9core.Main;
7 | import org.l2x9.l2x9core.command.BaseTabCommand;
8 |
9 | import java.util.ArrayList;
10 | import java.util.List;
11 |
12 | public class SpawnCommand extends BaseTabCommand {
13 | public SpawnCommand() {
14 | super(
15 | "spawn",
16 | "/spawn ",
17 | "l2x9core.command.spawnshit"
18 | );
19 | }
20 |
21 | @Override
22 | public void execute(CommandSender sender, String[] args, Main plugin) {
23 | Player player = getSenderAsPlayer(sender);
24 | if (player != null) {
25 | if (args.length == 2) {
26 | try {
27 | if (getEntityTypes().contains(args[1])) {
28 | int amount = Integer.parseInt(args[0]);
29 | for (int i = 0; i < amount; i++) {
30 | player.getWorld().spawnEntity(player.getLocation(), EntityType.valueOf(args[1].toUpperCase()));
31 | }
32 | } else {
33 | sendErrorMessage(sender, "Invalid entity " + args[1]);
34 | }
35 | } catch (NumberFormatException e) {
36 | sendErrorMessage(sender, "Invalid argument type the argument " + args[0] + " must be a number");
37 | }
38 | } else {
39 | sendErrorMessage(sender, getUsage());
40 | }
41 | } else {
42 | sendErrorMessage(sender, PLAYER_ONLY);
43 | }
44 | }
45 |
46 | public List getEntityTypes() {
47 | List entityTypes = new ArrayList<>();
48 | for (EntityType entityType : EntityType.values()) {
49 | entityTypes.add(entityType.toString().toLowerCase());
50 | }
51 | return entityTypes;
52 | }
53 |
54 | @Override
55 | public List onTab(String[] args) {
56 | return getEntityTypes();
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/command/commands/SpeedCommand.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.command.commands;
2 |
3 | import org.bukkit.command.CommandSender;
4 | import org.bukkit.entity.Player;
5 | import org.l2x9.l2x9core.Main;
6 | import org.l2x9.l2x9core.command.BaseCommand;
7 |
8 | public class SpeedCommand extends BaseCommand {
9 |
10 | public SpeedCommand() {
11 | super(
12 | "speed",
13 | "/speed ",
14 | "l2x9core.command.speed",
15 | "Turn up your fly speed");
16 | }
17 |
18 | @Override
19 | public void execute(CommandSender sender, String[] args, Main plugin) {
20 | Player player = getSenderAsPlayer(sender);
21 | if (player != null) {
22 | try {
23 | if (args.length > 0) {
24 | float speed = Float.parseFloat(args[0]);
25 | if (!(speed > 1)) {
26 | player.setFlySpeed(speed);
27 | sendMessage(player, "&6Fly speed set to&r&c " + speed);
28 | } else {
29 | sendErrorMessage(player, "Flying speed must not be above 1");
30 | }
31 | } else {
32 | sendMessage(sender, "&6Please note that the default flight speed is&r&c 0.1");
33 | sendErrorMessage(sender, getUsage());
34 |
35 | }
36 | } catch (NumberFormatException e) {
37 | sendErrorMessage(player, getUsage());
38 | }
39 | } else {
40 | sendErrorMessage(sender, PLAYER_ONLY);
41 | }
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/command/commands/UUidCommand.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.command.commands;
2 |
3 | import net.md_5.bungee.api.chat.ClickEvent;
4 | import net.md_5.bungee.api.chat.ComponentBuilder;
5 | import net.md_5.bungee.api.chat.HoverEvent;
6 | import net.md_5.bungee.api.chat.TextComponent;
7 | import org.bukkit.Bukkit;
8 | import org.bukkit.OfflinePlayer;
9 | import org.bukkit.command.CommandSender;
10 | import org.l2x9.l2x9core.Main;
11 | import org.l2x9.l2x9core.command.BaseCommand;
12 |
13 | public class UUidCommand extends BaseCommand {
14 |
15 | public UUidCommand() {
16 | super(
17 | "uuid",
18 | "/uuid ",
19 | "l2x9core.command.uuid",
20 | "Get the uuid of the specified player");
21 | }
22 |
23 | @Override
24 | public void execute(CommandSender sender, String[] args, Main plugin) {
25 | if (args.length > 0) {
26 | OfflinePlayer target = Bukkit.getOfflinePlayer(args[0]);
27 | sendClickableMessage(
28 | sender,
29 | "&6The UUID of&r&c " + target.getName() + "&r&6 is &r&c" + target.getUniqueId().toString(),
30 | "&a&l&lClick to copy",
31 | target.getUniqueId().toString(),
32 | ClickEvent.Action.SUGGEST_COMMAND
33 | );
34 |
35 | } else {
36 | sendErrorMessage(sender, "Please include at least one argument /uuid ");
37 | }
38 | }
39 |
40 | private void sendClickableMessage(CommandSender sender, String message, String hoverText, String command, ClickEvent.Action action) {
41 | TextComponent msg = new TextComponent(net.md_5.bungee.api.ChatColor.translateAlternateColorCodes('&', message));
42 | msg.setClickEvent(new ClickEvent(action, command));
43 | msg.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT,
44 | new ComponentBuilder(net.md_5.bungee.api.ChatColor.translateAlternateColorCodes('&', hoverText))
45 | .create()));
46 | sender.spigot().sendMessage(msg);
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/command/commands/UptimeCommand.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.command.commands;
2 |
3 |
4 | import org.bukkit.command.CommandSender;
5 | import org.l2x9.l2x9core.Main;
6 | import org.l2x9.l2x9core.command.BaseCommand;
7 | import org.l2x9.l2x9core.util.Utils;
8 |
9 | public class UptimeCommand extends BaseCommand {
10 |
11 | public UptimeCommand() {
12 | super(
13 | "uptime",
14 | "/uptime",
15 | "l2x9core.command.uptime",
16 | "Show the uptime of the server");
17 | }
18 |
19 | @Override
20 | public void execute(CommandSender sender, String[] args, Main plugin) {
21 | sendMessage(sender, "&6The server has had &r&c" + Utils.getFormattedInterval(System.currentTimeMillis() - Main.startTime) + "&r&6 uptime");
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/command/commands/WorldSwitcher.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.command.commands;
2 |
3 | import org.bukkit.Bukkit;
4 | import org.bukkit.Location;
5 | import org.bukkit.World;
6 | import org.bukkit.command.CommandSender;
7 | import org.bukkit.entity.Player;
8 | import org.l2x9.l2x9core.Main;
9 | import org.l2x9.l2x9core.command.BaseTabCommand;
10 | import org.l2x9.l2x9core.util.Utils;
11 |
12 | import java.util.Arrays;
13 | import java.util.Collections;
14 | import java.util.List;
15 |
16 | public class WorldSwitcher extends BaseTabCommand {
17 |
18 | public WorldSwitcher() {
19 | super(
20 | "world",
21 | "/world ",
22 | "l2x9core.command.world",
23 | "Switch worlds",
24 | new String[]{
25 | "overworld::Teleport your self to the overworld",
26 | "nether::Teleport your self to the nether",
27 | "end::Teleport your self to the end"
28 | }
29 | );
30 | }
31 |
32 | @Override
33 | public void execute(CommandSender sender, String[] args, Main plugin) {
34 | Player player = getSenderAsPlayer(sender);
35 | if (player != null) {
36 | if (args.length > 0) {
37 | switch (args[0]) {
38 | case "overworld":
39 | int x = player.getLocation().getBlockX();
40 | int y = player.getLocation().getBlockY();
41 | int z = player.getLocation().getBlockZ();
42 | World overWorld = Bukkit.getWorld(plugin.getConfig().getString("World-name"));
43 | player.teleport(new Location(overWorld, x, y, z));
44 | Utils.sendMessage(player, "&6Teleporting to &r&c" + args[0]);
45 | break;
46 | case "nether":
47 | int netherX = player.getLocation().getBlockX();
48 | int netherY = player.getLocation().getBlockY();
49 | int netherZ = player.getLocation().getBlockZ();
50 | World netherWorld = Bukkit.getWorld(plugin.getConfig().getString("World-name").concat("_nether"));
51 | if (netherY < 128) {
52 | player.teleport(new Location(netherWorld, netherX, 125, netherZ));
53 | } else {
54 | player.teleport(new Location(netherWorld, netherX, netherY, netherZ));
55 |
56 | }
57 | Utils.sendMessage(player, "&6Teleporting to &r&c" + args[0]);
58 | break;
59 | case "end":
60 | int endX = player.getLocation().getBlockX();
61 | int endY = player.getLocation().getBlockY();
62 | int endZ = player.getLocation().getBlockZ();
63 | World endWorld = Bukkit
64 | .getWorld(plugin.getConfig().getString("World-name").concat("_the_end"));
65 | player.teleport(new Location(endWorld, endX, endY, endZ));
66 | Utils.sendMessage(player, "&6Teleporting to &r&c" + args[0]);
67 | break;
68 | default:
69 | Utils.sendMessage(sender, "&4Error:&r&c Unknown world");
70 | break;
71 | }
72 | } else {
73 | sendErrorMessage(sender, "Please include one argument /world ");
74 | }
75 | } else {
76 | sendErrorMessage(sender, PLAYER_ONLY);
77 | }
78 | }
79 |
80 | @Override
81 | public List onTab(String[] args) {
82 | List list;
83 | if (args.length > 0) {
84 | if (args[0].startsWith("o")) {
85 | list = Collections.singletonList("overworld");
86 | return list;
87 | }
88 | if (args[0].startsWith("e")) {
89 | list = Collections.singletonList("end");
90 | return list;
91 | }
92 | if (args[0].startsWith("n")) {
93 | list = Collections.singletonList("nether");
94 | return list;
95 | }
96 | } else {
97 | list = Arrays.asList("overworld", "nether", "end");
98 | return list;
99 | }
100 | return null;
101 | }
102 | }
103 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/BlockPlace.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners;
2 |
3 | import org.bukkit.Material;
4 | import org.bukkit.block.Block;
5 | import org.bukkit.entity.Player;
6 | import org.bukkit.event.EventHandler;
7 | import org.bukkit.event.Listener;
8 | import org.bukkit.event.block.BlockBreakEvent;
9 | import org.bukkit.event.block.BlockPlaceEvent;
10 | import org.l2x9.l2x9core.Main;
11 | import org.l2x9.l2x9core.util.Utils;
12 |
13 | public class BlockPlace implements Listener {
14 | Main plugin;
15 |
16 | public BlockPlace(Main plugin) {
17 | this.plugin = plugin;
18 | }
19 |
20 | @EventHandler
21 | public void onBlockPlace(BlockPlaceEvent event) {
22 | try {
23 | Player player = event.getPlayer();
24 | if (plugin.getConfigBoolean("IllegalBlock-Place.Enabled")) {
25 | switch (event.getBlock().getType()) {
26 | case BEDROCK:
27 | event.setCancelled(true);
28 | Utils.sendMessage(player, plugin.getConfig().getString("IllegalBlock-Place.Bedrock"));
29 | event.getPlayer().getInventory().getItemInMainHand().setType(Material.AIR);
30 | break;
31 | case ENDER_PORTAL_FRAME:
32 | if (!(player.getInventory().getItemInMainHand().getType() == Material.EYE_OF_ENDER)) {
33 | if (!(player.getInventory().getItemInOffHand().getType() == Material.EYE_OF_ENDER)) {
34 | event.setCancelled(true);
35 | Utils.sendMessage(player, plugin.getConfig().getString("IllegalBlock-Place.End_Portal_Frame"));
36 | event.getPlayer().getInventory().getItemInMainHand().setType(Material.AIR);
37 | }
38 | }
39 | break;
40 | case BARRIER:
41 | event.setCancelled(true);
42 | Utils.sendMessage(player, plugin.getConfig().getString("IllegalBlock-Place.Barrier"));
43 | event.getPlayer().getInventory().getItemInMainHand().setType(Material.AIR);
44 | break;
45 | case MOB_SPAWNER:
46 | event.setCancelled(true);
47 | Utils.sendMessage(player, plugin.getConfig().getString("IllegalBlock-Place.Mob_Spawner"));
48 | event.getPlayer().getInventory().getItemInMainHand().setType(Material.AIR);
49 | break;
50 | }
51 | }
52 | } catch (Error | Exception throwable) {
53 |
54 | }
55 | }
56 |
57 | @EventHandler
58 | public void onBreak(BlockBreakEvent event) {
59 | try {
60 | if (event.getBlock().getType() == Material.BEDROCK) {
61 | event.setCancelled(true);
62 | }
63 | } catch (Error | Exception throwable) {
64 |
65 | }
66 | }
67 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/CommandEvent.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners;
2 |
3 | import org.bukkit.entity.Player;
4 | import org.bukkit.event.EventHandler;
5 | import org.bukkit.event.Listener;
6 | import org.bukkit.event.player.PlayerCommandPreprocessEvent;
7 | import org.l2x9.l2x9core.Main;
8 | import org.l2x9.l2x9core.util.Utils;
9 |
10 | public class CommandEvent implements Listener {
11 | Main plugin;
12 |
13 | public CommandEvent(Main plugin) {
14 | this.plugin = plugin;
15 | }
16 |
17 | @EventHandler
18 | public void onCMD(PlayerCommandPreprocessEvent event) {
19 | try {
20 | int spawn = plugin.getConfig().getInt("Spawn.Radius");
21 | Player player = event.getPlayer();
22 | if (!player.isOp() && player.getLocation().getBlockX() < spawn && player.getLocation().getBlockX() > -spawn
23 | && player.getLocation().getBlockZ() < spawn && player.getLocation().getBlockZ() > -spawn) {
24 | if (event.getMessage().toLowerCase().contains("/home")) {
25 | event.setCancelled(true);
26 | Utils.sendMessage(player, plugin.getConfig().getString("Spawn.Message").replace("%r%", "" + spawn + ""));
27 |
28 | }
29 | }
30 | if (player.isInsideVehicle()) {
31 | if (event.getMessage().toLowerCase().contains("/tpa") || event.getMessage().toLowerCase().contains("/home")) {
32 | event.setCancelled(true);
33 | Utils.sendMessage(player, plugin.getConfig().getString("tp.prevent.message"));
34 |
35 | }
36 | }
37 | } catch (Error | Exception throwable) {
38 |
39 | }
40 | }
41 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/ConnectionMessages.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners;
2 |
3 | import org.bukkit.Bukkit;
4 | import org.bukkit.command.Command;
5 | import org.bukkit.command.CommandExecutor;
6 | import org.bukkit.command.CommandSender;
7 | import org.bukkit.entity.Player;
8 | import org.bukkit.event.EventHandler;
9 | import org.bukkit.event.Listener;
10 | import org.bukkit.event.player.PlayerJoinEvent;
11 | import org.bukkit.event.player.PlayerQuitEvent;
12 | import org.l2x9.l2x9core.Main;
13 | import org.l2x9.l2x9core.util.Utils;
14 |
15 | import java.util.HashMap;
16 |
17 | public class ConnectionMessages implements Listener, CommandExecutor {
18 | HashMap toggled = new HashMap<>();
19 | Main plugin;
20 |
21 | public ConnectionMessages(Main plugin) {
22 | this.plugin = plugin;
23 | }
24 |
25 | @EventHandler
26 | public void onJoin(PlayerJoinEvent event) {
27 | event.setJoinMessage(null);
28 | for (Player player : Bukkit.getOnlinePlayers()) {
29 | toggled.putIfAbsent(player.getUniqueId().toString(), true);
30 | if (toggled.get(player.getUniqueId().toString())) {
31 | Utils.sendMessage(player, plugin.getConfig().getString("Connection.Player-Join-Message").replace("%player%", event.getPlayer().getDisplayName()));
32 | }
33 | }
34 | }
35 |
36 | @EventHandler
37 | public void onLeave(PlayerQuitEvent event) {
38 | event.setQuitMessage(null);
39 | for (Player player : Bukkit.getOnlinePlayers()) {
40 | if (toggled.get(player.getUniqueId().toString())) {
41 | Utils.sendMessage(player, plugin.getConfig().getString("Connection.Player-Leave-Message").replace("%player%", event.getPlayer().getDisplayName()));
42 | }
43 | }
44 | }
45 |
46 | @Override
47 | public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
48 | if (sender instanceof Player) {
49 | Player player = (Player) sender;
50 | if (toggled.get(player.getUniqueId().toString())) {
51 | Utils.sendMessage(player, "&6Turned off connection messages");
52 | toggled.replace(player.getUniqueId().toString(), false);
53 | } else {
54 | Utils.sendMessage(player, "&6Turned connection messages on");
55 | toggled.replace(player.getUniqueId().toString(), true);
56 | }
57 | } else {
58 | Utils.sendMessage(sender, "&cYou must be a player");
59 | }
60 | return true;
61 | }
62 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/DeopOnLeave.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners;
2 |
3 | import org.bukkit.entity.Player;
4 | import org.bukkit.event.EventHandler;
5 | import org.bukkit.event.Listener;
6 | import org.bukkit.event.player.PlayerKickEvent;
7 | import org.bukkit.event.player.PlayerQuitEvent;
8 | import org.l2x9.l2x9core.Main;
9 |
10 | public class DeopOnLeave implements Listener {
11 | Main plugin;
12 | public DeopOnLeave(Main plugin) {
13 | this.plugin = plugin;
14 | }
15 |
16 | @EventHandler
17 | public void onLeave(PlayerQuitEvent event) {
18 | Player player = event.getPlayer();
19 | if (plugin.getConfigBoolean("DeopOnLeave") && player.isOp()) {
20 | player.setOp(false);
21 | }
22 | }
23 | @EventHandler
24 | public void onKick(PlayerKickEvent event) {
25 | Player player = event.getPlayer();
26 | if (plugin.getConfigBoolean("DeopOnLeave") && player.isOp()) {
27 | player.setOp(false);
28 | }
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/DupeEvt.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners;
2 |
3 | import org.bukkit.entity.Entity;
4 | import org.bukkit.entity.Item;
5 | import org.bukkit.event.EventHandler;
6 | import org.bukkit.event.Listener;
7 | import org.bukkit.event.inventory.InventoryMoveItemEvent;
8 | import org.bukkit.event.inventory.InventoryType;
9 | import org.l2x9.l2x9core.util.Utils;
10 | import org.l2x9.saldupe.api.PlayerDupeEvent;
11 |
12 | import java.util.ArrayList;
13 |
14 | public class DupeEvt implements Listener {
15 | @EventHandler
16 | public void onDupe(PlayerDupeEvent event) {
17 | try {
18 | ArrayList items = new ArrayList<>();
19 | for (Entity entity : event.getPlayer().getLocation().getNearbyEntities(30, 30, 30)) {
20 | if (entity instanceof Item) {
21 | items.add(entity);
22 | }
23 | }
24 | if (items.size() > 20) {
25 | for (Entity entity : items) {
26 | if (entity != null) {
27 | entity.remove();
28 | }
29 | }
30 | }
31 | } catch (Error | Exception throwable) {
32 |
33 |
34 | }
35 | }
36 |
37 | @EventHandler
38 | public void onHopper(InventoryMoveItemEvent event) {
39 | try {
40 | if (Utils.getTps() < 17) {
41 | if (event.getSource().getType() == InventoryType.HOPPER) {
42 | event.setCancelled(true);
43 | }
44 | }
45 | } catch (Error | Exception throwable) {
46 |
47 |
48 | }
49 | }
50 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/GamemodeChange.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners;
2 |
3 | import org.bukkit.event.EventHandler;
4 | import org.bukkit.event.Listener;
5 | import org.bukkit.event.player.PlayerGameModeChangeEvent;
6 | import org.l2x9.l2x9core.Main;
7 |
8 | public class GamemodeChange implements Listener {
9 | Main plugin;
10 |
11 | public GamemodeChange(Main plugin) {
12 | this.plugin = plugin;
13 | }
14 |
15 | @EventHandler
16 | public void onGamemodeChange(PlayerGameModeChangeEvent event) {
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/JoinEvent.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners;
2 |
3 | import org.bukkit.Bukkit;
4 | import org.bukkit.ChatColor;
5 | import org.bukkit.entity.Player;
6 | import org.bukkit.event.EventHandler;
7 | import org.bukkit.event.Listener;
8 | import org.bukkit.event.player.PlayerJoinEvent;
9 | import org.bukkit.event.player.PlayerKickEvent;
10 | import org.bukkit.potion.PotionEffect;
11 | import org.l2x9.l2x9core.Main;
12 | import org.l2x9.l2x9core.util.Utils;
13 |
14 | public class JoinEvent implements Listener {
15 | Main plugin;
16 |
17 | public JoinEvent(Main plugin) {
18 | this.plugin = plugin;
19 | }
20 |
21 | @EventHandler
22 | public void onJoin(PlayerJoinEvent e) {
23 | try {
24 | Player player = e.getPlayer();
25 | if (player.getActivePotionEffects() != null) {
26 | for (PotionEffect effects : player.getActivePotionEffects()) {
27 | if (effects.getAmplifier() > 5) {
28 | player.removePotionEffect(effects.getType());
29 | }
30 | }
31 |
32 | }
33 | if (plugin.getConfigBoolean("FirstJoin.Enabled")) {
34 | if (!player.hasPlayedBefore()) {
35 | Bukkit.getServer().broadcastMessage(ChatColor.translateAlternateColorCodes('&',
36 | plugin.getConfig().getString("FirstJoin.Message").replace("{Player}", player.getName())));
37 | }
38 | }
39 | } catch (Error | Exception throwable) {
40 | }
41 | }
42 |
43 | @EventHandler
44 | public void onKick(PlayerKickEvent event) {
45 | if (event.getReason().equalsIgnoreCase("Kicked for spamming")) {
46 | event.setCancelled(true);
47 | }
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/MoveEvent.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners;
2 |
3 | import org.bukkit.ChatColor;
4 | import org.bukkit.Location;
5 | import org.bukkit.World.Environment;
6 | import org.bukkit.entity.Player;
7 | import org.bukkit.event.EventHandler;
8 | import org.bukkit.event.Listener;
9 | import org.bukkit.event.player.PlayerMoveEvent;
10 | import org.l2x9.l2x9core.Main;
11 | import org.l2x9.l2x9core.util.Utils;
12 |
13 | public class MoveEvent implements Listener {
14 | Main plugin;
15 |
16 | public MoveEvent(Main plugin) {
17 | this.plugin = plugin;
18 | }
19 |
20 | @EventHandler
21 | public void onMove(PlayerMoveEvent event) {
22 | try {
23 | Player player = event.getPlayer();
24 | int x = player.getLocation().getBlockX();
25 | int z = player.getLocation().getBlockZ();
26 | Location bottom = new Location(player.getWorld(), z, 5, x);
27 | Location top = new Location(player.getWorld(), z, 125, x);
28 | if (!(player.hasPermission("antifag.netherroof.bypass"))) {
29 |
30 | if (player.getWorld().getEnvironment() == Environment.NETHER
31 | && player.getLocation().getBlockY() > plugin.getConfig().getInt("Nether.Top-Layer")
32 | && !player.isOp()) {
33 |
34 | player.teleport(top);
35 | player.sendMessage(ChatColor.translateAlternateColorCodes('&',
36 | plugin.getConfig().getString("Nether.Top-message")));
37 | if (plugin.getConfig().getString("Nether.top-bottom-do-damage").equalsIgnoreCase("true")) {
38 | player.setHealth(0);
39 | }
40 | }
41 | if (player.getWorld().getEnvironment() == Environment.NETHER
42 | && player.getLocation().getBlockY() < plugin.getConfig().getInt("Nether.Bottom-Layer")
43 | && !player.isOp()) {
44 |
45 | player.teleport(bottom);
46 | player.sendMessage(ChatColor.translateAlternateColorCodes('&',
47 | plugin.getConfig().getString("Nether.Bottom-message")));
48 | if (plugin.getConfig().getString("Nether.top-bottom-do-damage").equalsIgnoreCase("true")) {
49 | player.damage(40);
50 |
51 | }
52 | }
53 | }
54 | } catch (Error | Exception throwable) {
55 | }
56 | }
57 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/PlayerChat.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners;
2 |
3 | import org.bukkit.entity.Player;
4 | import org.bukkit.event.EventHandler;
5 | import org.bukkit.event.Listener;
6 | import org.bukkit.event.player.AsyncPlayerChatEvent;
7 | import org.bukkit.event.player.PlayerCommandPreprocessEvent;
8 | import org.l2x9.l2x9core.Main;
9 | import org.l2x9.l2x9core.util.Cooldown;
10 | import org.l2x9.l2x9core.util.Utils;
11 |
12 | import java.util.List;
13 |
14 | public class PlayerChat implements Listener {
15 | Cooldown cm = new Cooldown();
16 | Main plugin;
17 |
18 | public PlayerChat(Main plugin) {
19 | this.plugin = plugin;
20 | }
21 |
22 | @EventHandler
23 | public void onChat(AsyncPlayerChatEvent event) {
24 | try {
25 | if (plugin.getConfigBoolean("Chat.Enabled")) {
26 | Player player = event.getPlayer();
27 | if (!player.isOp()) {
28 | if (cm.checkCooldown(player)) {
29 | cm.setCooldown(player, plugin.getConfig().getInt("Chat.Cooldown"));
30 | } else {
31 | event.setCancelled(true);
32 | }
33 | }
34 | if (!player.isOp()) {
35 | if (plugin.getConfig().getStringList("Chat.Blocked-words") != null) {
36 | List list = plugin.getConfig().getStringList("Chat.Blocked-words");
37 | boolean hasBlackListedWord = false;
38 | for (String word : list) {
39 | if (event.getMessage().toLowerCase().contains(word)) {
40 | hasBlackListedWord = true;
41 | break;
42 | }
43 | }
44 | if (hasBlackListedWord) {
45 | Utils.println(Utils.getPrefix() + "&6Prevented &r&c" + player.getName() + " &r&6from advertising");
46 | event.setCancelled(true);
47 | if (!event.getMessage().startsWith(">")) {
48 | if (!event.getMessage().startsWith("#")) {
49 | Utils.sendMessage(event.getPlayer(), "<" + player.getName() + "> " + event.getMessage());
50 | } else {
51 | Utils.sendMessage(event.getPlayer(), "<" + player.getName() + "> " + "&e" + event.getMessage());
52 | }
53 | } else {
54 | Utils.sendMessage(event.getPlayer(), "<" + player.getName() + "> " + "&a" + event.getMessage());
55 | }
56 | }
57 | }
58 | }
59 | }
60 | } catch (Error | Exception throwable) {
61 |
62 | }
63 | }
64 |
65 | @EventHandler
66 | public void onCommand(PlayerCommandPreprocessEvent event) {
67 | if (plugin.getConfigBoolean("Chat.Enabled")) {
68 | Player player = event.getPlayer();
69 | if (!player.isOp()) {
70 | if (cm.checkCooldown(player)) {
71 | cm.setCooldown(player, plugin.getConfig().getInt("Chat.Cooldown"));
72 | } else {
73 | event.setCancelled(true);
74 | }
75 | }
76 | }
77 | }
78 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/antiillegal/AntiIllegal.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.antiillegal;
2 |
3 | public @interface AntiIllegal {
4 | String EventName() default "AntiIllegalEvent";
5 | }
6 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/antiillegal/BlockPlace.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.antiillegal;
2 |
3 | import org.bukkit.ChatColor;
4 | import org.bukkit.Material;
5 | import org.bukkit.block.ShulkerBox;
6 | import org.bukkit.enchantments.Enchantment;
7 | import org.bukkit.event.EventHandler;
8 | import org.bukkit.event.Listener;
9 | import org.bukkit.event.block.BlockPlaceEvent;
10 | import org.bukkit.inventory.Inventory;
11 | import org.bukkit.inventory.ItemStack;
12 | import org.bukkit.inventory.meta.BlockStateMeta;
13 | import org.bukkit.inventory.meta.ItemMeta;
14 | import org.l2x9.l2x9core.Main;
15 | import org.l2x9.l2x9core.util.Utils;
16 |
17 | import java.util.Map.Entry;
18 |
19 | public class BlockPlace implements Listener {
20 | Main plugin;
21 |
22 | public BlockPlace(Main plugin) {
23 | this.plugin = plugin;
24 | }
25 |
26 | public static void removeColours(ItemStack item, ItemMeta meta) {
27 | String name = ChatColor.stripColor(meta.getDisplayName());
28 | meta.setDisplayName(ChatColor.stripColor(meta.getDisplayName()));
29 | if (name.toCharArray().length > 35) {
30 | String newName = name.substring(0, 35);
31 | meta.setDisplayName(newName);
32 | }
33 | item.setItemMeta(meta);
34 | }
35 |
36 | @EventHandler
37 | @AntiIllegal(EventName = "BlockPlaceEvent")
38 | public void onPlace(BlockPlaceEvent event) {
39 | try {
40 | if (plugin.getConfig().getBoolean("Antiillegal.Block-Place-Enabled")) {
41 | if (plugin.getItemUtils().isIllegal(event.getItemInHand())) {
42 | event.setCancelled(true);
43 | event.getPlayer().getInventory().getItemInMainHand().setType(Material.AIR);
44 | }
45 | ItemStack itemStack = event.getItemInHand();
46 | BlockStateMeta blockStateMeta = null;
47 | ShulkerBox shulkerBox = null;
48 | boolean illegalsFound = false;
49 | if (itemStack.getItemMeta() instanceof BlockStateMeta) {
50 | blockStateMeta = (BlockStateMeta) itemStack.getItemMeta();
51 | if (blockStateMeta.getBlockState() instanceof ShulkerBox) {
52 | shulkerBox = (ShulkerBox) blockStateMeta.getBlockState();
53 | Inventory boxInventory = shulkerBox.getInventory();
54 | for (ItemStack item : boxInventory.getContents()) {
55 | if (item != null) {
56 | if (plugin.getItemUtils().isArmor(item) || plugin.getItemUtils().isTool(item)) {
57 | if (item.getDurability() > item.getType().getMaxDurability()) {
58 | item.setDurability(item.getType().getMaxDurability());
59 | illegalsFound = true;
60 | event.setCancelled(true);
61 | }
62 | if (item.getDurability() < 0) {
63 | item.setDurability((short) 1);
64 | illegalsFound = true;
65 | event.setCancelled(true);
66 | }
67 | }
68 | if (plugin.getItemUtils().isIllegal(item)) {
69 | boxInventory.remove(item);
70 | illegalsFound = true;
71 | event.setCancelled(true);
72 | }
73 | if (plugin.getItemUtils().hasIllegalNBT(item)) {
74 | boxInventory.remove(item);
75 | illegalsFound = true;
76 | event.setCancelled(true);
77 | }
78 | if (plugin.getItemUtils().isOverstacked(item)) {
79 | item.setAmount(item.getMaxStackSize());
80 | illegalsFound = true;
81 | event.setCancelled(true);
82 | }
83 | if (plugin.getItemUtils().hasIllegalEnchants(item)) {
84 | for (Entry enchantmentIntegerEntry : item.getEnchantments().entrySet()) {
85 | item.removeEnchantment(enchantmentIntegerEntry.getKey());
86 | }
87 | illegalsFound = true;
88 | event.setCancelled(true);
89 | }
90 | if (item.hasItemMeta()) {
91 | ItemMeta meta = item.getItemMeta();
92 | if (meta.getDisplayName() != null) {
93 | removeColours(item, meta);
94 | blockStateMeta.setBlockState(shulkerBox);
95 | itemStack.setItemMeta(blockStateMeta);
96 | }
97 | if (plugin.getItemUtils().isEnchantedBlock(item)) {
98 | for (Entry enchantmentIntegerEntry : item.getEnchantments().entrySet()) {
99 | item.removeEnchantment(enchantmentIntegerEntry.getKey());
100 | illegalsFound = true;
101 | event.setCancelled(true);
102 | }
103 | }
104 | }
105 | }
106 | }
107 | }
108 | }
109 | if (illegalsFound) {
110 | blockStateMeta.setBlockState(shulkerBox);
111 | itemStack.setItemMeta(blockStateMeta);
112 | event.setCancelled(true);
113 | }
114 | }
115 |
116 | } catch (Error | Exception throwable) {
117 |
118 | }
119 | }
120 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/antiillegal/ChunkLoad.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.antiillegal;
2 |
3 | import org.bukkit.block.BlockState;
4 | import org.bukkit.block.Container;
5 | import org.bukkit.event.EventHandler;
6 | import org.bukkit.event.Listener;
7 | import org.bukkit.event.world.ChunkLoadEvent;
8 | import org.l2x9.l2x9core.Main;
9 | import org.l2x9.l2x9core.util.Utils;
10 |
11 | public class ChunkLoad implements Listener {
12 | Main plugin;
13 |
14 | public ChunkLoad(Main plugin) {
15 | this.plugin = plugin;
16 | }
17 |
18 | @EventHandler
19 | @AntiIllegal(EventName = "ChunkLoadEvent")
20 | public void onLoad(ChunkLoadEvent event) {
21 | try {
22 | if (plugin.getConfig().getBoolean("Antiillegal.ChunkLoad-Enabled")) {
23 | for (BlockState state : event.getChunk().getTileEntities()) {
24 | if (state instanceof Container) {
25 | Container container = (Container) state;
26 | plugin.getItemUtils().deleteIllegals(container.getInventory());
27 |
28 | }
29 | }
30 | }
31 | } catch (Error | Exception throwable) {
32 |
33 | }
34 | }
35 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/antiillegal/HopperTansfer.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.antiillegal;
2 |
3 | import org.bukkit.ChatColor;
4 | import org.bukkit.block.ShulkerBox;
5 | import org.bukkit.event.EventHandler;
6 | import org.bukkit.event.Listener;
7 | import org.bukkit.event.inventory.InventoryMoveItemEvent;
8 | import org.bukkit.inventory.Inventory;
9 | import org.bukkit.inventory.ItemStack;
10 | import org.bukkit.inventory.meta.BlockStateMeta;
11 | import org.bukkit.inventory.meta.ItemMeta;
12 | import org.l2x9.l2x9core.Main;
13 | import org.l2x9.l2x9core.util.Utils;
14 |
15 | public class HopperTansfer implements Listener {
16 | Main plugin;
17 |
18 | public HopperTansfer(Main plugin) {
19 | this.plugin = plugin;
20 | }
21 |
22 | @EventHandler
23 | @AntiIllegal(EventName = "InventoryMoveItemEvent")
24 | public void onInventoryClose(InventoryMoveItemEvent event) {
25 | try {
26 | if (plugin.getConfig().getBoolean("Antiillegal.HopperTransfer-Enabled")) {
27 | Inventory inv = event.getSource();
28 | if (inv.getContents() != null) {
29 | for (ItemStack item : inv.getStorageContents()) {
30 | if (item != null) {
31 | if (plugin.getItemUtils().isArmor(item) || plugin.getItemUtils().isTool(item)) {
32 | if (item.getDurability() > item.getType().getMaxDurability()) {
33 | item.setDurability(item.getType().getMaxDurability());
34 | }
35 | if (item.getDurability() < 0) {
36 | item.setDurability((short) 1);
37 | }
38 |
39 | }
40 | if (plugin.getItemUtils().isIllegal(item)) {
41 | inv.remove(item);
42 | event.setCancelled(true);
43 | }
44 | if (plugin.getItemUtils().hasIllegalNBT(item)) {
45 | inv.remove(item);
46 | event.setCancelled(true);
47 |
48 | }
49 | if (plugin.getItemUtils().isOverstacked(item)) {
50 | item.setAmount(item.getMaxStackSize());
51 | event.setCancelled(true);
52 | }
53 | if (plugin.getItemUtils().hasIllegalEnchants(item)) {
54 | inv.remove(item);
55 | event.setCancelled(true);
56 | }
57 | if (item.hasItemMeta()) {
58 | ItemMeta meta = item.getItemMeta();
59 | if (meta.hasDisplayName()) {
60 | String name = ChatColor.stripColor(meta.getDisplayName());
61 | meta.setDisplayName(ChatColor.stripColor(meta.getDisplayName()));
62 | event.setCancelled(true);
63 | if (name.toCharArray().length > 35) {
64 | String newName = name.substring(0, 35);
65 | meta.setDisplayName(newName);
66 | event.setCancelled(true);
67 | }
68 | item.setItemMeta(meta);
69 | }
70 | if (plugin.getItemUtils().isEnchantedBlock(item)) {
71 | event.setCancelled(true);
72 | }
73 | if (item.getItemMeta() instanceof BlockStateMeta) {
74 | BlockStateMeta itemMeta = (BlockStateMeta) item.getItemMeta();
75 | if (itemMeta.getBlockState() instanceof ShulkerBox) {
76 | ShulkerBox shulker = (ShulkerBox) itemMeta.getBlockState();
77 | for (ItemStack shulkerItem : shulker.getInventory().getContents()) {
78 | if (shulkerItem != null) {
79 | if (plugin.getItemUtils().isArmor(item) || plugin.getItemUtils().isTool(item)) {
80 | if (item.getDurability() > item.getType().getMaxDurability()) {
81 | inv.remove(item);
82 | event.setCancelled(true);
83 | }
84 | if (item.getDurability() < 0) {
85 | inv.remove(item);
86 | event.setCancelled(true);
87 | }
88 | }
89 | if (plugin.getItemUtils().isIllegal(shulkerItem)) {
90 | inv.remove(item);
91 | }
92 | if (plugin.getItemUtils().hasIllegalNBT(shulkerItem)) {
93 | inv.remove(item);
94 | event.setCancelled(true);
95 | }
96 | if (plugin.getItemUtils().isOverstacked(shulkerItem)) {
97 | inv.remove(item);
98 | event.setCancelled(true);
99 | }
100 | if (plugin.getItemUtils().hasIllegalEnchants(shulkerItem)) {
101 | inv.remove(item);
102 | event.setCancelled(true);
103 | }
104 | }
105 | }
106 | }
107 | }
108 | }
109 | }
110 | }
111 | }
112 | }
113 | } catch (Error | Exception throwable) {
114 |
115 | }
116 | }
117 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/antiillegal/InventoryClose.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.antiillegal;
2 |
3 | import org.bukkit.block.ShulkerBox;
4 | import org.bukkit.event.EventHandler;
5 | import org.bukkit.event.Listener;
6 | import org.bukkit.event.inventory.InventoryCloseEvent;
7 | import org.bukkit.event.inventory.InventoryType;
8 | import org.bukkit.inventory.Inventory;
9 | import org.bukkit.inventory.ItemStack;
10 | import org.bukkit.inventory.meta.BlockStateMeta;
11 | import org.l2x9.l2x9core.Main;
12 | import org.l2x9.l2x9core.util.Utils;
13 |
14 | public class InventoryClose implements Listener {
15 | Main plugin;
16 |
17 | public InventoryClose(Main plugin) {
18 | this.plugin = plugin;
19 | }
20 |
21 | @EventHandler
22 | @AntiIllegal(EventName = "InventoryCloseEvent")
23 | public void onInventoryClose(InventoryCloseEvent event) {
24 | try {
25 | if (plugin.getConfig().getBoolean("Antiillegal.InventoryClose-Enabled")) {
26 | Inventory inv = event.getInventory();
27 | plugin.getItemUtils().deleteIllegals(inv);
28 | Inventory playerInv = event.getPlayer().getInventory();
29 | plugin.getItemUtils().deleteIllegals(playerInv);
30 | if (event.getInventory().getType() == InventoryType.SHULKER_BOX) {
31 | Inventory shulkerInv = event.getInventory();
32 | for (ItemStack item : shulkerInv.getContents()) {
33 | if (item != null) {
34 | if (item.getItemMeta() instanceof BlockStateMeta) {
35 | BlockStateMeta blockStateMeta = (BlockStateMeta) item.getItemMeta();
36 | if (blockStateMeta.getBlockState() instanceof ShulkerBox) {
37 | shulkerInv.remove(item);
38 | }
39 | }
40 | }
41 | }
42 | }
43 | }
44 | } catch (Error | Exception throwable) {
45 |
46 | }
47 | }
48 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/antiillegal/InventoryOpen.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.antiillegal;
2 |
3 | import org.bukkit.event.EventHandler;
4 | import org.bukkit.event.Listener;
5 | import org.bukkit.event.inventory.InventoryOpenEvent;
6 | import org.bukkit.inventory.Inventory;
7 | import org.l2x9.l2x9core.Main;
8 | import org.l2x9.l2x9core.util.Utils;
9 |
10 | public class InventoryOpen implements Listener {
11 | Main plugin;
12 |
13 | public InventoryOpen(Main plugin) {
14 | this.plugin = plugin;
15 | }
16 |
17 | @EventHandler
18 | @AntiIllegal(EventName = "InventoryCloseEvent")
19 | public void onInventoryClose(InventoryOpenEvent event) {
20 | try {
21 | if (plugin.getConfig().getBoolean("Antiillegal.InventoryOpen-Enabled")) {
22 | Inventory inv = event.getInventory();
23 | plugin.getItemUtils().deleteIllegals(inv);
24 | }
25 | } catch (Error | Exception throwable) {
26 |
27 | }
28 | }
29 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/antiillegal/ItemPickup.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.antiillegal;
2 |
3 | import org.bukkit.block.ShulkerBox;
4 | import org.bukkit.event.EventHandler;
5 | import org.bukkit.event.Listener;
6 | import org.bukkit.event.player.PlayerPickupItemEvent;
7 | import org.bukkit.inventory.ItemStack;
8 | import org.bukkit.inventory.meta.BlockStateMeta;
9 | import org.l2x9.l2x9core.Main;
10 | import org.l2x9.l2x9core.util.Utils;
11 |
12 | @SuppressWarnings("deprecation")
13 | public class ItemPickup implements Listener {
14 | Main plugin;
15 |
16 | public ItemPickup(Main plugin) {
17 | this.plugin = plugin;
18 | }
19 |
20 | @EventHandler
21 | @AntiIllegal(EventName = "PlayerPickupItemEvent")
22 | public void onPickup(PlayerPickupItemEvent event) {
23 | try {
24 | if (plugin.getConfig().getBoolean("Antiillegal.ItemPickup-Enabled")) {
25 | ItemStack item = event.getItem().getItemStack();
26 | if (plugin.getItemUtils().isEnchantedBlock(item) || plugin.getItemUtils().hasIllegalNBT(item) || plugin.getItemUtils().hasIllegalEnchants(item)
27 | || plugin.getItemUtils().isOverstacked(item) || plugin.getItemUtils().isIllegal(item)) {
28 | event.setCancelled(true);
29 | event.getItem().remove();
30 | }
31 | if (item.getItemMeta() instanceof BlockStateMeta) {
32 | BlockStateMeta itemMeta = (BlockStateMeta) item.getItemMeta();
33 | if (itemMeta.getBlockState() instanceof ShulkerBox) {
34 | ShulkerBox box = (ShulkerBox) itemMeta.getBlockState();
35 | for (ItemStack shulkerItem : box.getInventory().getContents()) {
36 | if (shulkerItem != null) {
37 | if (plugin.getItemUtils().isArmor(item) || plugin.getItemUtils().isTool(item)) {
38 | if (item.getDurability() > item.getType().getMaxDurability()) {
39 | event.getItem().remove();
40 | event.setCancelled(true);
41 | }
42 | if (item.getDurability() < 0) {
43 | event.getItem().remove();
44 | event.setCancelled(true);
45 | }
46 | }
47 | if (plugin.getItemUtils().isIllegal(shulkerItem)) {
48 | event.getItem().remove();
49 | }
50 | if (plugin.getItemUtils().hasIllegalNBT(shulkerItem)) {
51 | event.getItem().remove();
52 | event.setCancelled(true);
53 |
54 | }
55 | if (plugin.getItemUtils().isOverstacked(shulkerItem)) {
56 | event.getItem().remove();
57 | event.setCancelled(true);
58 | }
59 | if (plugin.getItemUtils().hasIllegalEnchants(shulkerItem)) {
60 | event.getItem().remove();
61 | event.setCancelled(true);
62 | }
63 | }
64 | }
65 | }
66 | }
67 | }
68 | } catch (Error | Exception throwable) {
69 |
70 | }
71 | }
72 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/antiillegal/ItemUtils.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.antiillegal;
2 |
3 | import org.bukkit.ChatColor;
4 | import org.bukkit.Material;
5 | import org.bukkit.block.ShulkerBox;
6 | import org.bukkit.enchantments.Enchantment;
7 | import org.bukkit.inventory.Inventory;
8 | import org.bukkit.inventory.ItemFlag;
9 | import org.bukkit.inventory.ItemStack;
10 | import org.bukkit.inventory.meta.BlockStateMeta;
11 | import org.bukkit.inventory.meta.ItemMeta;
12 | import org.l2x9.l2x9core.Main;
13 | import org.l2x9.l2x9core.util.Utils;
14 |
15 | import java.util.*;
16 | import java.util.Map.Entry;
17 | import java.util.logging.Level;
18 |
19 | public class ItemUtils {
20 | Main plugin;
21 |
22 | public ItemUtils(Main plugin) {
23 | this.plugin = plugin;
24 | }
25 |
26 | public boolean isArmor(ItemStack item) {
27 | List armor = Arrays.asList(Material.LEATHER_BOOTS, Material.CHAINMAIL_BOOTS, Material.IRON_BOOTS,
28 | Material.DIAMOND_BOOTS, Material.GOLD_BOOTS, Material.LEATHER_LEGGINGS, Material.CHAINMAIL_LEGGINGS,
29 | Material.IRON_LEGGINGS, Material.GOLD_LEGGINGS, Material.DIAMOND_LEGGINGS,
30 | Material.CHAINMAIL_CHESTPLATE, Material.LEATHER_CHESTPLATE, Material.GOLD_CHESTPLATE,
31 | Material.DIAMOND_CHESTPLATE, Material.IRON_CHESTPLATE, Material.LEATHER_HELMET,
32 | Material.CHAINMAIL_HELMET, Material.DIAMOND_HELMET, Material.IRON_HELMET, Material.GOLD_HELMET,
33 | Material.ELYTRA);
34 | return armor.contains(item.getType());
35 | }
36 |
37 | public boolean isTool(ItemStack item) {
38 | List tools = Arrays.asList(Material.DIAMOND_AXE, Material.DIAMOND_PICKAXE, Material.DIAMOND_SWORD,
39 | Material.DIAMOND_HOE, Material.DIAMOND_SPADE, Material.IRON_AXE, Material.IRON_HOE,
40 | Material.IRON_PICKAXE, Material.IRON_SPADE, Material.IRON_SWORD, Material.GOLD_AXE, Material.GOLD_HOE,
41 | Material.GOLD_PICKAXE, Material.GOLD_SWORD, Material.WOOD_AXE, Material.WOOD_HOE, Material.WOOD_PICKAXE,
42 | Material.WOOD_SWORD, Material.CARROT_STICK, Material.SHEARS, Material.FISHING_ROD, Material.BOW,
43 | Material.FLINT_AND_STEEL);
44 | return tools.contains(item.getType());
45 | }
46 |
47 | public boolean isIllegal(ItemStack item) {
48 | List items = plugin.getConfig().getStringList("Antiillegal.Illegal-Items-List");
49 | List materials = new ArrayList<>();
50 | List knownMaterials = Arrays.asList(Material.values());
51 | for (String material : items) {
52 | String upperCaseMat = material.toUpperCase();
53 | if (knownMaterials.contains(Material.getMaterial(upperCaseMat))) {
54 | materials.add(Material.getMaterial(upperCaseMat));
55 | } else {
56 | plugin.getLogger().log(Level.SEVERE, ChatColor.translateAlternateColorCodes('&', "&cInvalid configuration option Antiillegal.Illegal-Items-List " + material));
57 | }
58 | }
59 | return materials.contains(item.getType());
60 | }
61 |
62 | public boolean hasIllegalNBT(ItemStack item) {
63 | if (item.hasItemMeta()) {
64 | ItemMeta meta = item.getItemMeta();
65 | return meta.hasItemFlag(ItemFlag.HIDE_ATTRIBUTES) || meta.hasItemFlag(ItemFlag.HIDE_DESTROYS)
66 | || meta.hasItemFlag(ItemFlag.HIDE_ENCHANTS) || meta.hasItemFlag(ItemFlag.HIDE_PLACED_ON)
67 | || meta.hasItemFlag(ItemFlag.HIDE_POTION_EFFECTS) || meta.hasItemFlag(ItemFlag.HIDE_UNBREAKABLE)
68 | || meta.isUnbreakable() || meta.hasLore();
69 | }
70 | return false;
71 | }
72 |
73 | public boolean isOverstacked(ItemStack item) {
74 | if (plugin.getConfigBoolean("Antiillegal.Delete-Stacked-Items")) {
75 | return item.getAmount() > item.getMaxStackSize();
76 | } else {
77 | return false;
78 | }
79 | }
80 |
81 | public boolean hasIllegalEnchants(ItemStack item) {
82 | Map enchants = item.getEnchantments();
83 | for (int level : enchants.values()) {
84 | return level > 5;
85 | }
86 | return false;
87 | }
88 |
89 | public boolean isEnchantedBlock(ItemStack item) {
90 | if (item.getType().isBlock()) {
91 | if (item.hasItemMeta()) {
92 | return item.getItemMeta().hasEnchants();
93 | }
94 | }
95 | return false;
96 | }
97 |
98 | public void deleteIllegals(Inventory inventory) {
99 | try {
100 | ItemUtils utils = plugin.getItemUtils();
101 | ItemStack itemStack = null;
102 | boolean illegalsFound = false;
103 | if (inventory.getContents() != null) {
104 | for (ItemStack item : inventory.getStorageContents()) {
105 | if (item != null) {
106 | if (utils.isArmor(item) || utils.isTool(item)) {
107 | if (item.getDurability() > item.getType().getMaxDurability()) {
108 | item.setDurability(item.getType().getMaxDurability());
109 | itemStack = item;
110 | }
111 | if (item.getDurability() < 0) {
112 | item.setDurability((short) 1);
113 | itemStack = item;
114 | }
115 |
116 | }
117 | if (utils.isIllegal(item)) {
118 | inventory.remove(item);
119 | illegalsFound = true;
120 | itemStack = item;
121 | }
122 | if (utils.hasIllegalNBT(item)) {
123 | inventory.remove(item);
124 | illegalsFound = true;
125 | itemStack = item;
126 |
127 | }
128 | if (utils.isOverstacked(item)) {
129 | item.setAmount(item.getMaxStackSize());
130 | itemStack = item;
131 | }
132 | if (utils.hasIllegalEnchants(item)) {
133 | for (Entry enchantmentIntegerEntry : item.getEnchantments().entrySet()) {
134 | item.removeEnchantment(enchantmentIntegerEntry.getKey());
135 | illegalsFound = true;
136 | itemStack = item;
137 | }
138 | }
139 | if (item.hasItemMeta()) {
140 | ItemMeta meta = item.getItemMeta();
141 | if (meta.getDisplayName() != null) {
142 | BlockPlace.removeColours(item, meta);
143 | }
144 | if (utils.isEnchantedBlock(item)) {
145 | Iterator> enchants = item.getEnchantments().entrySet()
146 | .iterator();
147 | illegalsFound = true;
148 | itemStack = item;
149 | while (enchants.hasNext()) {
150 | item.removeEnchantment(enchants.next().getKey());
151 | }
152 | }
153 | if (item.getItemMeta() instanceof BlockStateMeta) {
154 | BlockStateMeta blockStateMeta = (BlockStateMeta) item.getItemMeta();
155 | if (blockStateMeta.getBlockState() instanceof ShulkerBox) {
156 | ShulkerBox shulker = (ShulkerBox) blockStateMeta.getBlockState();
157 | for (ItemStack shulkerItem : shulker.getInventory().getContents()) {
158 | if (shulkerItem != null) {
159 | if (utils.isArmor(shulkerItem) || utils.isTool(shulkerItem)) {
160 | if (shulkerItem.getDurability() > shulkerItem.getType().getMaxDurability()) {
161 | shulkerItem.setDurability(shulkerItem.getType().getMaxDurability());
162 | illegalsFound = true;
163 | itemStack = item;
164 | }
165 | if (shulkerItem.getDurability() < 0) {
166 | shulkerItem.setDurability((short) 1);
167 | illegalsFound = true;
168 | itemStack = item;
169 | }
170 | }
171 | if (utils.isIllegal(shulkerItem)) {
172 | shulker.getInventory().remove(shulkerItem);
173 | illegalsFound = true;
174 | itemStack = item;
175 | }
176 | if (utils.hasIllegalNBT(shulkerItem)) {
177 | shulker.getInventory().remove(shulkerItem);
178 | illegalsFound = true;
179 | itemStack = item;
180 | }
181 | if (utils.isOverstacked(shulkerItem)) {
182 | shulkerItem.setAmount(shulkerItem.getType().getMaxStackSize());
183 | illegalsFound = true;
184 | itemStack = item;
185 | }
186 | if (utils.hasIllegalEnchants(shulkerItem)) {
187 | for (Entry enchantmentIntEntry : shulkerItem.getEnchantments().entrySet()) {
188 | if (enchantmentIntEntry.getValue() > enchantmentIntEntry.getKey().getMaxLevel()) {
189 | if (enchantmentIntEntry.getKey().canEnchantItem(shulkerItem)) {
190 | shulkerItem.addEnchantment(enchantmentIntEntry.getKey(), enchantmentIntEntry.getKey().getMaxLevel());
191 | } else {
192 | shulkerItem.removeEnchantment(enchantmentIntEntry.getKey());
193 | }
194 | }
195 | }
196 | illegalsFound = true;
197 | itemStack = item;
198 | }
199 | if (utils.isEnchantedBlock(shulkerItem)) {
200 | shulkerItem.removeEnchantment(shulkerItem.getEnchantments().entrySet().iterator().next().getKey());
201 | illegalsFound = true;
202 | itemStack = item;
203 | }
204 | }
205 | }
206 | blockStateMeta.setBlockState(shulker);
207 | item.setItemMeta(blockStateMeta);
208 | }
209 | }
210 | }
211 | }
212 | }
213 | }
214 | if (illegalsFound) {
215 | Utils.println(Utils.getPrefix() + "&6Deleted illegals " + itemStack.getType() + " " + itemStack.getI18NDisplayName() + " " + itemStack.getEnchantments());
216 | }
217 | } catch (Error | Exception throwable) {
218 |
219 | }
220 | }
221 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/antiillegal/PlayerScroll.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.antiillegal;
2 |
3 | import org.bukkit.entity.Player;
4 | import org.bukkit.event.EventHandler;
5 | import org.bukkit.event.Listener;
6 | import org.bukkit.event.player.PlayerItemHeldEvent;
7 | import org.l2x9.l2x9core.Main;
8 | import org.l2x9.l2x9core.util.Utils;
9 |
10 | public class PlayerScroll implements Listener {
11 | Main plugin;
12 |
13 | public PlayerScroll(Main plugin) {
14 | this.plugin = plugin;
15 | }
16 |
17 | @EventHandler
18 | public void onItemMove(PlayerItemHeldEvent event) {
19 | try {
20 | if (plugin.getConfig().getBoolean("Antiillegal.PlayerHotbarMove-Enabled")) {
21 | Player player = event.getPlayer();
22 | plugin.getItemUtils().deleteIllegals(player.getInventory());
23 | }
24 | } catch (Error | Exception throwable) {
25 |
26 | }
27 | }
28 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/antilag/BlockPhysics.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.antilag;
2 |
3 | import org.bukkit.Material;
4 | import org.bukkit.event.EventHandler;
5 | import org.bukkit.event.Listener;
6 | import org.bukkit.event.block.BlockFromToEvent;
7 | import org.l2x9.l2x9core.Main;
8 | import org.l2x9.l2x9core.util.Utils;
9 |
10 | public class BlockPhysics implements Listener {
11 | Main plugin;
12 |
13 | public BlockPhysics(Main plugin) {
14 | this.plugin = plugin;
15 | }
16 |
17 | @EventHandler
18 | public void onLiquidSpread(BlockFromToEvent event) {
19 | try {
20 | int disableTPS = plugin.getConfig().getInt("BlockPhysics-disable-tps");
21 | if (Utils.getTps() < disableTPS) {
22 | Material type = event.getBlock().getType();
23 | if (isChecked(type)) {
24 | event.setCancelled(true);
25 | }
26 | }
27 | } catch (Error | Exception throwable) {
28 |
29 | }
30 | }
31 |
32 | private boolean isChecked(Material material) {
33 | switch (material) {
34 | case LAVA:
35 | case STATIONARY_LAVA:
36 | case WATER:
37 | case STATIONARY_WATER:
38 | return true;
39 | }
40 | return false;
41 | }
42 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/antilag/BlockRedstone.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.antilag;
2 |
3 | import net.md_5.bungee.api.chat.ClickEvent;
4 | import org.bukkit.Bukkit;
5 | import org.bukkit.ChatColor;
6 | import org.bukkit.Material;
7 | import org.bukkit.block.Block;
8 | import org.bukkit.entity.Entity;
9 | import org.bukkit.entity.Player;
10 | import org.bukkit.event.EventHandler;
11 | import org.bukkit.event.Listener;
12 | import org.bukkit.event.block.Action;
13 | import org.bukkit.event.block.BlockPistonExtendEvent;
14 | import org.bukkit.event.block.BlockPistonRetractEvent;
15 | import org.bukkit.event.block.BlockRedstoneEvent;
16 | import org.bukkit.event.player.PlayerInteractEvent;
17 | import org.l2x9.l2x9core.Main;
18 | import org.l2x9.l2x9core.util.SecondPassEvent;
19 | import org.l2x9.l2x9core.util.Utils;
20 |
21 | import java.util.HashMap;
22 |
23 | public class BlockRedstone implements Listener {
24 | private final HashMap leverHashMap = new HashMap<>();
25 | int alertAmount = 0;
26 | Main plugin;
27 |
28 | public BlockRedstone(Main plugin) {
29 | this.plugin = plugin;
30 | }
31 |
32 | @EventHandler
33 | public void onRedstoneTick(BlockRedstoneEvent event) {
34 | try {
35 | if (Utils.getTps() <= plugin.getConfig().getInt("Redstone.Disable-TPS")
36 | && !(event.getBlock().getType() == Material.TRAPPED_CHEST)) {
37 | Block block = event.getBlock();
38 | String fagMachine = "Deleted a taco machine at " + block.getLocation().getBlockX() + " "
39 | + block.getLocation().getBlockY() + " " + block.getLocation().getBlockZ() + " in world "
40 | + block.getLocation().getWorld().getName() + "";
41 | event.setNewCurrent(0);
42 | event.getBlock().setType(Material.AIR);
43 | sendOpMessage("&6&l[&b&lLEF&6&l] &6Removed a lag machine at &r&1" + block.getLocation().getBlockX() + " " + block.getLocation().getBlockY() + " " + block.getLocation().getBlockZ() + "&r&6 owned by &r&1 " + Utils.getNearbyPlayer(50, block.getLocation()).getName(), "&aClick to telepot to the player", "/tp " + Utils.getNearbyPlayer(50, block.getLocation()).getName(), ClickEvent.Action.RUN_COMMAND);
44 | //event.getBlock().getLocation().getWorld().strikeLightning(block.getLocation());
45 | System.out.println(ChatColor.translateAlternateColorCodes('&', "&a" + fagMachine));
46 | boolean alreadySent = false;
47 | for (Entity entity : block.getChunk().getEntities()) {
48 | if (!(entity instanceof Player)) {
49 | entity.remove();
50 | if (!alreadySent) {
51 | System.out.println(ChatColor.GREEN + "Removed " + block.getChunk().getEntities().length + " " + entity.getType().toString().toLowerCase().concat("s") + " from a laggy chunk");
52 | Utils.sendOpMessage("&6&l[&b&lLEF&6&l] &6Removed &r&1" + block.getChunk().getEntities().length + " " + entity.getType().toString().toLowerCase().concat("s") + "&r&6 from a laggy chunk");
53 | alreadySent = true;
54 | }
55 | }
56 | }
57 | }
58 | } catch (Error | Exception throwable) {
59 | //
60 | }
61 | }
62 |
63 | @EventHandler
64 | public void PistonExtendEvent(BlockPistonExtendEvent event) {
65 | try {
66 | if (Utils.getTps() <= plugin.getConfig().getInt("Redstone.Disable-TPS")
67 | && !(event.getBlock().getType() == Material.TRAPPED_CHEST)) {
68 | Block block = event.getBlock();
69 | String fagMachine = "Deleted a taco machine at " + block.getLocation().getBlockX() + " "
70 | + block.getLocation().getBlockY() + " " + block.getLocation().getBlockZ() + " in world "
71 | + block.getLocation().getWorld().getName() + "";
72 | event.getBlock().setType(Material.AIR);
73 | sendOpMessage("&6&l[&b&lLEF&6&l] &6Removed a lag machine at &r&1" + block.getLocation().getBlockX() + " " + block.getLocation().getBlockY() + " " + block.getLocation().getBlockZ() + "&r&6 owned by &r&1 " + Utils.getNearbyPlayer(50, block.getLocation()).getName(), "&aClick to telepot to the player", "/tp " + Utils.getNearbyPlayer(50, block.getLocation()).getName(), ClickEvent.Action.RUN_COMMAND);
74 | //event.getBlock().getLocation().getWorld().strikeLightning(block.getLocation());
75 | System.out.println(ChatColor.translateAlternateColorCodes('&', "&a" + fagMachine));
76 | boolean alreadySent = false;
77 | for (Entity entity : block.getChunk().getEntities()) {
78 | if (!(entity instanceof Player)) {
79 | entity.remove();
80 | if (!alreadySent) {
81 | System.out.println(ChatColor.GREEN + "Removed " + block.getChunk().getEntities().length + " " + entity.getType().toString().toLowerCase().concat("s") + " from a laggy chunk");
82 | Utils.sendOpMessage("&6&l[&b&lLEF&6&l] &6Removed &r&1" + block.getChunk().getEntities().length + " " + entity.getType().toString().toLowerCase().concat("s") + "&r&6 from a laggy chunk");
83 | alreadySent = true;
84 | }
85 | }
86 | }
87 | }
88 | } catch (Exception e) {
89 | e.printStackTrace();
90 | }
91 | }
92 | @EventHandler
93 | public void PistonRetractEvent(BlockPistonRetractEvent event) {
94 | try {
95 | if (Utils.getTps() <= plugin.getConfig().getInt("Redstone.Disable-TPS")
96 | && !(event.getBlock().getType() == Material.TRAPPED_CHEST)) {
97 | Block block = event.getBlock();
98 | String fagMachine = "Deleted a taco machine at " + block.getLocation().getBlockX() + " "
99 | + block.getLocation().getBlockY() + " " + block.getLocation().getBlockZ() + " in world "
100 | + block.getLocation().getWorld().getName() + "";
101 | event.getBlock().setType(Material.AIR);
102 | sendOpMessage("&6&l[&b&lLEF&6&l] &6Removed a lag machine at &r&1" + block.getLocation().getBlockX() + " " + block.getLocation().getBlockY() + " " + block.getLocation().getBlockZ() + "&r&6 owned by &r&1 " + Utils.getNearbyPlayer(50, block.getLocation()).getName(), "&aClick to telepot to the player", "/tp " + Utils.getNearbyPlayer(50, block.getLocation()).getName(), ClickEvent.Action.RUN_COMMAND);
103 | //event.getBlock().getLocation().getWorld().strikeLightning(block.getLocation());
104 | System.out.println(ChatColor.translateAlternateColorCodes('&', "&a" + fagMachine));
105 | boolean alreadySent = false;
106 | for (Entity entity : block.getChunk().getEntities()) {
107 | if (!(entity instanceof Player)) {
108 | entity.remove();
109 | if (!alreadySent) {
110 | System.out.println(ChatColor.GREEN + "Removed " + block.getChunk().getEntities().length + " " + entity.getType().toString().toLowerCase().concat("s") + " from a laggy chunk");
111 | Utils.sendOpMessage("&6&l[&b&lLEF&6&l] &6Removed &r&1" + block.getChunk().getEntities().length + " " + entity.getType().toString().toLowerCase().concat("s") + "&r&6 from a laggy chunk");
112 | alreadySent = true;
113 | }
114 | }
115 | }
116 | }
117 | } catch (Exception e) {
118 | e.printStackTrace();
119 | }
120 | }
121 | @EventHandler
122 | public void onPull(PlayerInteractEvent event) {
123 | try {
124 | if (event.getAction() == Action.RIGHT_CLICK_BLOCK) {
125 | if (event.getClickedBlock().getType() == Material.LEVER) {
126 | Player player = event.getPlayer();
127 | if (leverHashMap.containsKey(player)) {
128 | leverHashMap.put(player, leverHashMap.get(player) + 1);
129 | } else {
130 | leverHashMap.put(player, 1);
131 | }
132 | if (leverHashMap.get(player) > 5) {
133 | event.setCancelled(true);
134 | Utils.kickPlayer(player, Utils.getPrefix() + "&6AntiFaggotExploit by Leee suck my fucking dick");
135 | leverHashMap.remove(player);
136 | }
137 | }
138 | }
139 | } catch (Error | Exception throwable) {
140 |
141 |
142 | }
143 | }
144 |
145 | @EventHandler
146 | public void onSecond(SecondPassEvent event) {
147 | Utils.secondPass(leverHashMap);
148 | }
149 |
150 | private void sendOpMessage(String message, String hoverText, String cmd, ClickEvent.Action action) {
151 | for (Player online : Bukkit.getOnlinePlayers()) {
152 | if (online.isOp()) {
153 | Utils.sendClickableMessage(online, message, hoverText, cmd, action);
154 | }
155 | }
156 | }
157 | }
158 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/antilag/Elytra.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.antilag;
2 |
3 | import org.bukkit.Location;
4 | import org.bukkit.Material;
5 | import org.bukkit.entity.Player;
6 | import org.bukkit.event.EventHandler;
7 | import org.bukkit.event.Listener;
8 | import org.bukkit.event.entity.EntityDamageEvent;
9 | import org.bukkit.event.entity.EntityToggleGlideEvent;
10 | import org.bukkit.event.player.PlayerMoveEvent;
11 | import org.l2x9.l2x9core.Main;
12 | import org.l2x9.l2x9core.util.Utils;
13 |
14 | public class Elytra implements Listener {
15 | Main plugin;
16 |
17 | public Elytra(Main plugin) {
18 | this.plugin = plugin;
19 | }
20 |
21 | @EventHandler
22 | public void NoElytraFallDamage(EntityDamageEvent event) {
23 | if (plugin.getConfigBoolean("Elytra.EnableNoFallDamage")) {
24 | if (event.getCause() == null) return;
25 | if (event.getEntity() == null) return;
26 | if (!(event.getEntity() instanceof Player)) return;
27 | Player player = (Player) event.getEntity();
28 | if (player.getInventory().getChestplate() == null) return;
29 | Material chestPlate = player.getInventory().getChestplate().getType();
30 | if (chestPlate == Material.ELYTRA) {
31 | event.setCancelled(event.getCause() == EntityDamageEvent.DamageCause.FALL);
32 | }
33 | }
34 | }
35 |
36 | @EventHandler
37 | public void onToggleGlide(EntityToggleGlideEvent event) {
38 | try {
39 | if (event.getEntity() instanceof Player) {
40 | Player player = (Player) event.getEntity();
41 | if (Utils.getTps() <= plugin.getConfig().getInt("Elytra.Disable-TPS")) {
42 | event.setCancelled(true);
43 | Utils.sendMessage(player, plugin.getConfig().getString("ElytraLowTPS.Message").replace("{tps}", "" + plugin.getConfig().getInt("Elytra.Disable-TPS")).replaceAll("&","§"));
44 | }
45 | }
46 | } catch (Error | Exception throwable) {
47 | }
48 | }
49 |
50 | @EventHandler
51 | public void onMove(PlayerMoveEvent event) {
52 | try {
53 | if (Utils.getTps() <= plugin.getConfig().getInt("Elytra.Disable-TPS")) {
54 | if (event.getPlayer().isGliding()) {
55 | event.getPlayer().setGliding(false);
56 | Utils.sendMessage(event.getPlayer(), plugin.getConfig().getString("ElytraLowTPS.Message").replace("{tps}", "" + plugin.getConfig().getInt("Elytra.Disable-TPS")).replaceAll("&","§"));
57 | }
58 | }
59 | Player player = event.getPlayer();
60 | Location from = event.getFrom();
61 | Location to = event.getTo();
62 | double distX = to.getX() - from.getX();
63 | double distZ = to.getZ() - from.getZ();
64 | double finalValue = Math.round(Math.hypot(distX, distZ));
65 | if (finalValue > plugin.getConfig().getInt("Elytra.SpeedLimit")) {
66 | event.setCancelled(true);
67 | if (player.isGliding()) {
68 | if (plugin.getConfigBoolean("Elytra.EnableTakingOffElytra")) {
69 | if (player.getInventory().getChestplate().getType() == Material.ELYTRA) {
70 | player.getWorld().dropItem(player.getLocation(), player.getInventory().getChestplate());
71 | player.getInventory().setChestplate(null);
72 | if (plugin.getConfigBoolean("Elytra.EnableOpMessages")) {
73 | if (plugin.getConfigBoolean("Elytra.EnableDamage")) {
74 | Utils.sendOpMessage(plugin.getConfig().getString("Elytra.SpeeedLimitReached-ops").replace("{name}", "" + player.getName()).replaceAll("&","§"));
75 | player.sendMessage(plugin.getConfig().getString("Elytra.SpeedLimitReached-message").replaceAll("&","§"));
76 | player.setGliding(false);
77 | player.damage(plugin.getConfig().getInt("Elytra.DamageAmount"));
78 | } else {
79 | Utils.sendOpMessage(plugin.getConfig().getString("Elytra.SpeeedLimitReached-ops").replace("{name}", "" + player.getName()).replaceAll("&","§"));
80 | player.sendMessage(plugin.getConfig().getString("Elytra.SpeedLimitReached-message").replaceAll("&","§"));
81 | player.setGliding(false);
82 | }
83 | } else {
84 | if (plugin.getConfigBoolean("Elytra.EnableDamage")) {
85 | player.sendMessage(plugin.getConfig().getString("Elytra.SpeedLimitReached-message"));
86 | player.setGliding(false);
87 | player.damage(plugin.getConfig().getInt("Elytra.DamageAmount"));
88 | } else {
89 | player.sendMessage(plugin.getConfig().getString("Elytra.SpeedLimitReached-message"));
90 | player.setGliding(false);
91 | }
92 | }
93 | }
94 | } else {
95 | if (plugin.getConfigBoolean("Elytra.EnableOpMessages")) {
96 | if (plugin.getConfigBoolean("Elytra.EnableDamage")) {
97 | Utils.sendOpMessage(plugin.getConfig().getString("Elytra.SpeeedLimitReached-ops").replace("{name}", "" + player.getName()).replaceAll("&","§"));
98 | player.sendMessage(plugin.getConfig().getString("Elytra.SpeedLimitReached-message").replaceAll("&","§"));
99 | player.setGliding(false);
100 | player.damage(plugin.getConfig().getInt("Elytra.DamageAmount"));
101 | } else {
102 | Utils.sendOpMessage(plugin.getConfig().getString("Elytra.SpeeedLimitReached-ops").replace("{name}", "" + player.getName()).replaceAll("&","§"));
103 | player.sendMessage(plugin.getConfig().getString("Elytra.SpeedLimitReached-message").replaceAll("&","§"));
104 | player.setGliding(false);
105 | }
106 | } else {
107 | if (plugin.getConfigBoolean("Elytra.EnableDamage")) {
108 | player.sendMessage(plugin.getConfig().getString("Elytra.SpeedLimitReached-message").replaceAll("&","§"));
109 | player.setGliding(false);
110 | player.damage(plugin.getConfig().getInt("Elytra.DamageAmount"));
111 | } else {
112 | player.sendMessage(plugin.getConfig().getString("Elytra.SpeedLimitReached-message").replaceAll("&","§"));
113 | player.setGliding(false);
114 | }
115 | }
116 | }
117 | }
118 | }
119 | } catch (Error | Exception throwable) {
120 |
121 | }
122 | }
123 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/antilag/EntityPerChunkLimit.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.antilag;
2 |
3 | import org.bukkit.Bukkit;
4 | import org.bukkit.Chunk;
5 | import org.bukkit.Material;
6 | import org.bukkit.World;
7 | import org.bukkit.entity.Entity;
8 | import org.bukkit.entity.EntityType;
9 | import org.bukkit.event.EventHandler;
10 | import org.bukkit.event.Listener;
11 | import org.bukkit.event.block.BlockFromToEvent;
12 | import org.bukkit.event.block.BlockPhysicsEvent;
13 | import org.l2x9.l2x9core.Main;
14 | import org.l2x9.l2x9core.util.TenSecondPassEvent;
15 |
16 | import java.util.Map;
17 |
18 | public class EntityPerChunkLimit implements Listener {
19 |
20 | @EventHandler
21 | public void onSecondPass(TenSecondPassEvent event) {
22 | Thread thread = new Thread(() -> {
23 | try {
24 | if (event.getPlugin().getConfigBoolean("EntityAmounts.EntityAmounts-Enabled")) {
25 | for (World world : Bukkit.getWorlds()) {
26 | for (Chunk chunk : world.getLoadedChunks()) {
27 | for (Entity entity : chunk.getEntities()) {
28 | for (Map.Entry integerEntry : event.getPlugin().getEntityAmounts().entrySet()) {
29 | EntityType type = EntityType.valueOf(integerEntry.getKey());
30 | int maxAmount = integerEntry.getValue();
31 | int amount = countEntityPerChunk(chunk, type);
32 | if (entity.getType() == type) {
33 | if (amount > maxAmount) {
34 | Bukkit.getScheduler().runTask(Main.getPlugin(Main.class), entity::remove);
35 | }
36 | }
37 | }
38 | }
39 | }
40 | }
41 | }
42 | } catch (Error | Exception ignored) {
43 | }
44 | });
45 | thread.start();
46 | }
47 |
48 | private int countEntityPerChunk(Chunk chunk, EntityType lookingFor) {
49 | int amount = 0;
50 | for (Entity entity : chunk.getEntities()) {
51 | if (entity.getType() == lookingFor) {
52 | amount++;
53 | }
54 | }
55 | return amount;
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/antilag/MinecartLag.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.antilag;
2 |
3 | import org.bukkit.ChatColor;
4 | import org.bukkit.Chunk;
5 | import org.bukkit.entity.Entity;
6 | import org.bukkit.entity.Player;
7 | import org.bukkit.entity.Vehicle;
8 | import org.bukkit.event.EventHandler;
9 | import org.bukkit.event.Listener;
10 | import org.bukkit.event.vehicle.VehicleCreateEvent;
11 | import org.bukkit.event.vehicle.VehicleMoveEvent;
12 | import org.l2x9.l2x9core.Main;
13 | import org.l2x9.l2x9core.util.Utils;
14 |
15 | public class MinecartLag implements Listener {
16 | Main plugin;
17 |
18 | public MinecartLag(Main plugin) {
19 | this.plugin = plugin;
20 | }
21 |
22 | @EventHandler
23 | public void onSpawn(VehicleCreateEvent event) {
24 | try {
25 | int ammount = 0;
26 | Chunk chunk = event.getVehicle().getChunk();
27 | Vehicle vehicle = event.getVehicle();
28 | Player player = Utils.getNearbyPlayer(20, vehicle.getLocation());
29 | String formattedName = vehicle.getType().toString().toLowerCase().concat("s");
30 | int max = plugin.getConfig().getInt("Minecart-per-chunk.limit");
31 | for (Entity ents : chunk.getEntities()) {
32 | if (ents instanceof Vehicle) {
33 | ammount++;
34 | }
35 | }
36 | if (ammount >= max) {
37 | event.setCancelled(true);
38 | Utils.sendMessage(player, Utils.getPrefix() + "&6Please limit " + formattedName + " to &r&c" + max + "&r&6 per chunk");
39 | Utils.sendOpMessage(Utils.getPrefix() + "&6Removed &r&3" + chunk.getEntities().length + " " + formattedName + "&r&6 from a lag machine owned by&r&3 " + player.getName());
40 | System.out.println(ChatColor.translateAlternateColorCodes('&', Utils.getPrefix() + "&6Removed &r&3" + chunk.getEntities().length + " " + formattedName + "&r&6 from a lag machine owned by&r&3 " + player.getName()));
41 | for (Entity ent : event.getVehicle().getChunk().getEntities()) {
42 | if (!(ent instanceof Player)) {
43 | ent.remove();
44 |
45 | }
46 | }
47 | }
48 | } catch (Error | Exception throwable) {
49 |
50 | }
51 | }
52 |
53 | @EventHandler
54 | public void onVehicleMove(VehicleMoveEvent event) {
55 | Chunk chunk = event.getVehicle().getChunk();
56 | Vehicle vehicle = event.getVehicle();
57 | String formattedName = vehicle.getType().toString().toLowerCase().concat("s").replace("_", " ");
58 | String formattedName1 = vehicle.getType().toString().toLowerCase().replace("_", " ");
59 | int max = plugin.getConfig().getInt("Minecart-per-chunk.limit");
60 | Player player = Utils.getNearbyPlayer(20, vehicle.getLocation());
61 | if (!event.getFrom().getChunk().equals(event.getTo().getChunk())) {
62 | if (chunk.getEntities().length >= max) {
63 | vehicle.remove();
64 | Utils.sendMessage(player,
65 | Utils.getPrefix() + "&6Please limit " + formattedName + " to &r&c" + max + "&r&6 per chunk");
66 | Utils.sendOpMessage(Utils.getPrefix() + "&6Deleted a &r&3" + formattedName1
67 | + "&r&6 from a lag machine owned by&r&3 " + player.getName() + " &4BYPASS ATTEMPT");
68 | System.out.println(ChatColor.translateAlternateColorCodes('&',
69 | Utils.getPrefix() + "&6Deleted a &r&3" + formattedName1
70 | + "&r&6 from a lag machine owned by&r&3 " + player.getName() + " &4BYPASS ATTEMPT"));
71 | }
72 | }
73 | }
74 | }
75 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/antilag/WitherSpawn.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.antilag;
2 |
3 | import org.bukkit.entity.Wither;
4 | import org.bukkit.event.EventHandler;
5 | import org.bukkit.event.Listener;
6 | import org.bukkit.event.entity.EntitySpawnEvent;
7 | import org.l2x9.l2x9core.util.Utils;
8 |
9 | public class WitherSpawn implements Listener {
10 | @EventHandler
11 | public void onWitherSpawn(EntitySpawnEvent event) {
12 | try {
13 | if (event.getEntity() instanceof Wither) {
14 | if (Utils.getTps() <= 16) {
15 | event.setCancelled(true);
16 |
17 | }
18 | }
19 | } catch (Error | Exception throwable) {
20 |
21 | }
22 | }
23 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/patches/BookBan.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.patches;
2 |
3 | import org.bukkit.Material;
4 | import org.bukkit.block.ShulkerBox;
5 | import org.bukkit.entity.Player;
6 | import org.bukkit.event.EventHandler;
7 | import org.bukkit.event.EventPriority;
8 | import org.bukkit.event.Listener;
9 | import org.bukkit.event.player.PlayerJoinEvent;
10 | import org.bukkit.inventory.ItemStack;
11 | import org.bukkit.inventory.PlayerInventory;
12 | import org.bukkit.inventory.meta.BlockStateMeta;
13 | import org.bukkit.inventory.meta.BookMeta;
14 | import org.l2x9.l2x9core.util.Utils;
15 |
16 | import java.util.regex.Matcher;
17 | import java.util.regex.Pattern;
18 |
19 | public class BookBan implements Listener {
20 |
21 | @EventHandler(priority = EventPriority.HIGHEST)
22 | public void onJoin(PlayerJoinEvent event) {
23 | try {
24 | Player player = event.getPlayer();
25 | PlayerInventory inv = player.getInventory();
26 | for (ItemStack item : inv.getContents()) {
27 | if (item != null && item.getItemMeta() instanceof BlockStateMeta) {
28 | BlockStateMeta blockStateMeta = (BlockStateMeta) item.getItemMeta();
29 | if (blockStateMeta.getBlockState() instanceof ShulkerBox) {
30 | ShulkerBox shulker = (ShulkerBox) blockStateMeta.getBlockState();
31 | for (ItemStack shulkerItem : shulker.getInventory().getContents()) {
32 | if (shulkerItem != null) {
33 | if (shulkerItem.getType() == Material.WRITTEN_BOOK) {
34 | BookMeta book = (BookMeta) shulkerItem.getItemMeta();
35 | if (isBanBook(book)) {
36 | player.getWorld().dropItem(player.getLocation(), shulkerItem);
37 | shulker.getInventory().remove(shulkerItem);
38 | }
39 | }
40 | }
41 | }
42 | blockStateMeta.setBlockState(shulker);
43 | item.setItemMeta(blockStateMeta);
44 | }
45 | }
46 | }
47 | } catch (Error | Exception throwable) {
48 |
49 | }
50 | }
51 |
52 | private boolean isBanBook(BookMeta book) {
53 | for (String bookPages : book.getPages()) {
54 | Pattern pattern = Pattern.compile("[^a-zA-Z0-9]");
55 | Matcher matcher = pattern.matcher(bookPages);
56 | return matcher.find();
57 | }
58 | return false;
59 | }
60 | }
61 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/patches/BucketEvent.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.patches;
2 |
3 | import org.bukkit.Material;
4 | import org.bukkit.event.EventHandler;
5 | import org.bukkit.event.Listener;
6 | import org.bukkit.event.block.BlockDispenseEvent;
7 | import org.bukkit.event.player.PlayerBucketEmptyEvent;
8 | import org.l2x9.l2x9core.Main;
9 | import org.l2x9.l2x9core.util.Utils;
10 |
11 | public class BucketEvent implements Listener {
12 | Main plugin;
13 |
14 | public BucketEvent(Main plugin) {
15 | this.plugin = plugin;
16 | }
17 |
18 | @EventHandler
19 | public void onBucket(PlayerBucketEmptyEvent event) {
20 | // This is monkee code im gonna rewrite this soon
21 | //TODO Rewrite this patch
22 | try {
23 | int yNeg = event.getBlockClicked().getLocation().getBlockY() - 1;
24 | int yPos = event.getBlockClicked().getLocation().getBlockY() + 1;
25 | int xNeg = event.getBlockClicked().getLocation().getBlockX() - 1;
26 | int zNeg = event.getBlockClicked().getLocation().getBlockZ() - 1;
27 | int xPos = event.getBlockClicked().getLocation().getBlockX() + 1;
28 | int zPos = event.getBlockClicked().getLocation().getBlockZ() + 1;
29 | int x = event.getBlockClicked().getLocation().getBlockX();
30 | int z = event.getBlockClicked().getLocation().getBlockZ();
31 | int y = event.getBlockClicked().getLocation().getBlockY();
32 | if (event.getBlockClicked().getType() == Material.ENDER_PORTAL_FRAME
33 | || event.getBlockClicked().getLocation().getWorld().getBlockAt(x, yNeg, z)
34 | .getType() == Material.ENDER_PORTAL
35 | || event.getBlockClicked().getLocation().getWorld().getBlockAt(x, yPos, z)
36 | .getType() == Material.ENDER_PORTAL
37 | || event.getBlockClicked().getLocation().getWorld().getBlockAt(x, y, zNeg)
38 | .getType() == Material.ENDER_PORTAL
39 | || event.getBlockClicked().getLocation().getWorld().getBlockAt(xNeg, y, z)
40 | .getType() == Material.ENDER_PORTAL
41 | || event.getBlockClicked().getLocation().getWorld().getBlockAt(x, y, zPos)
42 | .getType() == Material.ENDER_PORTAL
43 | || event.getBlockClicked().getLocation().getWorld().getBlockAt(xPos, y, z)
44 | .getType() == Material.ENDER_PORTAL) {
45 | event.setCancelled(true);
46 | }
47 | } catch (Error | Exception throwable) {
48 | }
49 | }
50 |
51 | @EventHandler
52 | public void onDispense(BlockDispenseEvent event) {
53 | try {
54 | int yNeg = event.getBlock().getLocation().getBlockY() - 1;
55 | int yPos = event.getBlock().getLocation().getBlockY() + 1;
56 | int xNeg = event.getBlock().getLocation().getBlockX() - 1;
57 | int zNeg = event.getBlock().getLocation().getBlockZ() - 1;
58 | int xPos = event.getBlock().getLocation().getBlockX() + 1;
59 | int zPos = event.getBlock().getLocation().getBlockZ() + 1;
60 | int x = event.getBlock().getLocation().getBlockX();
61 | int z = event.getBlock().getLocation().getBlockZ();
62 | int y = event.getBlock().getLocation().getBlockY();
63 | if (event.getBlock().getType() == Material.ENDER_PORTAL_FRAME
64 | || event.getBlock().getLocation().getWorld().getBlockAt(x, yNeg, z).getType() == Material.ENDER_PORTAL
65 | || event.getBlock().getLocation().getWorld().getBlockAt(x, yPos, z).getType() == Material.ENDER_PORTAL
66 | || event.getBlock().getLocation().getWorld().getBlockAt(x, y, zNeg).getType() == Material.ENDER_PORTAL
67 | || event.getBlock().getLocation().getWorld().getBlockAt(xNeg, y, z).getType() == Material.ENDER_PORTAL
68 | || event.getBlock().getLocation().getWorld().getBlockAt(x, y, zPos).getType() == Material.ENDER_PORTAL
69 | || event.getBlock().getLocation().getWorld().getBlockAt(xPos, y, z)
70 | .getType() == Material.ENDER_PORTAL) {
71 | event.setCancelled(true);
72 | }
73 | } catch (Error | Exception throwable) {
74 | }
75 | }
76 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/patches/ChestLagFix.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.patches;
2 |
3 | import org.bukkit.Bukkit;
4 | import org.bukkit.Material;
5 | import org.bukkit.block.ShulkerBox;
6 | import org.bukkit.entity.Player;
7 | import org.bukkit.event.EventHandler;
8 | import org.bukkit.event.Listener;
9 | import org.bukkit.event.inventory.InventoryOpenEvent;
10 | import org.bukkit.event.inventory.InventoryType;
11 | import org.bukkit.inventory.Inventory;
12 | import org.bukkit.inventory.ItemStack;
13 | import org.bukkit.inventory.meta.BlockStateMeta;
14 | import org.bukkit.inventory.meta.BookMeta;
15 | import org.bukkit.plugin.Plugin;
16 | import org.bukkit.scheduler.BukkitScheduler;
17 | import org.l2x9.l2x9core.Main;
18 | import org.l2x9.l2x9core.util.SecondPassEvent;
19 | import org.l2x9.l2x9core.util.Utils;
20 |
21 | import java.util.HashMap;
22 | import java.util.regex.Matcher;
23 | import java.util.regex.Pattern;
24 |
25 | public class ChestLagFix implements Listener {
26 | public HashMap chestHashMap = new HashMap<>();
27 | Main plugin;
28 |
29 | public ChestLagFix(Main plugin) {
30 | this.plugin = plugin;
31 |
32 | }
33 |
34 | @EventHandler
35 | public void onInventoryOpen(InventoryOpenEvent event) {
36 | try {
37 | int maxSpam = plugin.getConfig().getInt("ChestLagFix.MaxOpensPerSecond");
38 | String kickMessage = plugin.getConfig().getString("ChestLagFix.KickMessage");
39 | boolean deleteBooks = plugin.getConfig().getBoolean("ChestLagFix.RemoveUnicodeBooks");
40 | InventoryType inventoryType = event.getInventory().getType();
41 | Player player = (Player) event.getPlayer();
42 | if (isCheckedInventory(inventoryType)) {
43 | if (chestHashMap.containsKey(player)) {
44 | chestHashMap.replace(player, chestHashMap.get(player) + 1);
45 | } else {
46 | chestHashMap.put(player, 1);
47 | }
48 | if (deleteBooks) {
49 | deleteNBTBooks(event.getInventory());
50 | }
51 | if (chestHashMap.get(player) > maxSpam) {
52 | Utils.kickPlayer(player, kickMessage);
53 | chestHashMap.remove(player);
54 | }
55 | }
56 | } catch (IllegalArgumentException e) {
57 | e.printStackTrace();
58 | }
59 | BukkitScheduler scheduler = Bukkit.getScheduler();
60 | scheduler.runTaskTimer((Plugin) this, () -> {
61 | if (Utils.getTps() <= 15) {
62 | chestHashMap.clear();
63 | }
64 | }, 20L * 1L /*<-- the initial delay */, 20L * 30L /*<-- the interval */);
65 | }
66 |
67 | @EventHandler
68 | public void onSecondPass(SecondPassEvent event) {
69 | Utils.secondPass(chestHashMap);
70 | }
71 |
72 | public boolean isCheckedInventory(InventoryType type) {
73 | switch (type) {
74 | case CHEST:
75 | case HOPPER:
76 | case ENDER_CHEST:
77 | case SHULKER_BOX:
78 | case DISPENSER:
79 | case DROPPER:
80 | return true;
81 | }
82 | return false;
83 | }
84 |
85 | private void deleteNBTBooks(Inventory inventory) {
86 | for (ItemStack item : inventory.getContents()) {
87 | if (item != null) {
88 | if (item.getType() == Material.WRITTEN_BOOK || item.getType() == Material.BOOK_AND_QUILL) {
89 | BookMeta bookMeta = (BookMeta) item.getItemMeta();
90 | if (isBanBook(bookMeta)) {
91 | inventory.remove(item);
92 | System.out.println("[ChestLagFix] Removed an NBT book from a chest");
93 | }
94 | }
95 | if (item.getItemMeta() instanceof BlockStateMeta) {
96 | BlockStateMeta blockStateMeta = (BlockStateMeta) item.getItemMeta();
97 | if (blockStateMeta.getBlockState() instanceof ShulkerBox) {
98 | ShulkerBox shulker = (ShulkerBox) blockStateMeta.getBlockState();
99 | for (ItemStack shulkerItem : shulker.getInventory().getContents()) {
100 | if (shulkerItem != null) {
101 | if (shulkerItem.getType() == Material.WRITTEN_BOOK || shulkerItem.getType() == Material.BOOK_AND_QUILL) {
102 | BookMeta book = (BookMeta) shulkerItem.getItemMeta();
103 | if (isBanBook(book)) {
104 | shulker.getInventory().remove(shulkerItem);
105 | System.out.println("[ChestLagFix] Removed an NBT book from a chest");
106 | }
107 | }
108 | }
109 | }
110 | blockStateMeta.setBlockState(shulker);
111 | item.setItemMeta(blockStateMeta);
112 | }
113 | }
114 | }
115 | }
116 | }
117 |
118 | private boolean isBanBook(BookMeta book) {
119 | for (String bookPages : book.getPages()) {
120 | Pattern pattern = Pattern.compile("[^a-zA-Z0-9]");
121 | Matcher matcher = pattern.matcher(bookPages);
122 | return matcher.find();
123 | }
124 | return false;
125 | }
126 | }
127 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/patches/ChinkBan.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.patches;
2 |
3 | import org.bukkit.ChatColor;
4 | import org.bukkit.Material;
5 | import org.bukkit.block.Block;
6 | import org.bukkit.entity.Entity;
7 | import org.bukkit.entity.ItemFrame;
8 | import org.bukkit.entity.Player;
9 | import org.bukkit.event.EventHandler;
10 | import org.bukkit.event.Listener;
11 | import org.bukkit.event.block.Action;
12 | import org.bukkit.event.block.BlockPlaceEvent;
13 | import org.bukkit.event.player.PlayerInteractEvent;
14 | import org.l2x9.l2x9core.Main;
15 | import org.l2x9.l2x9core.util.Utils;
16 |
17 | public class ChinkBan implements Listener {
18 | Main plugin;
19 |
20 | public ChinkBan(Main plugin) {
21 | this.plugin = plugin;
22 | }
23 |
24 | @EventHandler
25 | public void onPlace(BlockPlaceEvent event) {
26 | try {
27 | if (plugin.getConfigBoolean("ChunkBan.Enabled")) {
28 | Block block = event.getBlock();
29 | Player player = event.getPlayer();
30 | int x = block.getLocation().getBlockX();
31 | int y = block.getLocation().getBlockY();
32 | int z = block.getLocation().getBlockZ();
33 | String worldName = block.getWorld().getName();
34 | if (!(player.hasPermission("chunkban.bypass"))) {
35 | if (isChecked(block)) {
36 | if (event.getBlock().getChunk().getTileEntities().length > plugin.getConfig().getInt("ChunkBan.TileEntity-Max")) {
37 | event.setCancelled(true);
38 | player.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("ChunkBan.Prevent-Message")));
39 | }
40 | }
41 | }
42 | if (block.getType() == Material.SKULL || block.getType() == Material.SKULL_ITEM) {
43 | if (block.getChunk().getTileEntities().length > plugin.getConfig().getInt("ChunkBan.Skull-Max")) {
44 | event.setCancelled(true);
45 | player.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("ChunkBan.Prevent-Message")));
46 | }
47 | }
48 | }
49 | } catch (Error | Exception throwable) {
50 | }
51 | }
52 |
53 | @EventHandler
54 | public void onSpawn(PlayerInteractEvent event) {
55 | try {
56 | if (plugin.getConfigBoolean("ChunkBan.Enabled")) {
57 | if (event.getAction() == Action.RIGHT_CLICK_BLOCK && event.getItem() != null) {
58 | if (event.getItem().getType() == Material.ITEM_FRAME) {
59 | int x = event.getPlayer().getLocation().getBlockX();
60 | int y = event.getPlayer().getLocation().getBlockY();
61 | int z = event.getPlayer().getLocation().getBlockZ();
62 | Player player = event.getPlayer();
63 | String worldName = event.getPlayer().getWorld().getName();
64 | int amount = 0;
65 | for (Entity entity : event.getPlayer().getLocation().getChunk().getEntities()) {
66 | if (entity instanceof ItemFrame) {
67 | amount++;
68 | }
69 | }
70 | if (amount > plugin.getConfig().getInt("ChunkBan.TileEntity-Max")) {
71 | event.setCancelled(true);
72 | event.getPlayer().sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("ChunkBan.Prevent-Message")));
73 | }
74 | }
75 | }
76 | }
77 | } catch (Error | Exception throwable) {
78 | }
79 | }
80 |
81 | private boolean isChecked(Block block) {
82 | switch (block.getType()) {
83 | case FURNACE:
84 | case TRAPPED_CHEST:
85 | case ENCHANTMENT_TABLE:
86 | case WALL_BANNER:
87 | case WALL_SIGN:
88 | case HOPPER:
89 | case DROPPER:
90 | case DISPENSER:
91 | case BREWING_STAND:
92 | case BEACON:
93 | case SIGN_POST:
94 | case ENDER_CHEST:
95 | case FLOWER_POT:
96 | case BANNER:
97 | return true;
98 | }
99 | return false;
100 | }
101 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/patches/EntityDamageEvent.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.patches;
2 |
3 | import org.bukkit.Material;
4 | import org.bukkit.block.Dispenser;
5 | import org.bukkit.entity.Arrow;
6 | import org.bukkit.entity.Player;
7 | import org.bukkit.entity.TippedArrow;
8 | import org.bukkit.event.EventHandler;
9 | import org.bukkit.event.Listener;
10 | import org.bukkit.event.block.BlockDispenseEvent;
11 | import org.bukkit.event.entity.EntityDamageByEntityEvent;
12 | import org.bukkit.event.entity.PotionSplashEvent;
13 | import org.bukkit.event.entity.ProjectileHitEvent;
14 | import org.bukkit.event.player.PlayerItemConsumeEvent;
15 | import org.bukkit.inventory.ItemStack;
16 | import org.bukkit.inventory.meta.PotionMeta;
17 | import org.bukkit.potion.PotionEffect;
18 | import org.l2x9.l2x9core.Main;
19 | import org.l2x9.l2x9core.util.Utils;
20 |
21 | public class EntityDamageEvent implements Listener {
22 | Main plugin;
23 |
24 | public EntityDamageEvent(Main plugin) {
25 | this.plugin = plugin;
26 | }
27 |
28 | @EventHandler
29 | public void onDamage(EntityDamageByEntityEvent event) {
30 | if (plugin.getConfigBoolean("Antiillegal.Check-Illegal-Damage")) {
31 | if (event.getEntity() instanceof Player && event.getDamager() instanceof Player) {
32 | Player damager = (Player) event.getDamager();
33 | if (event.getDamage() > 30) {
34 | damager.damage(event.getDamage());
35 | event.setCancelled(true);
36 | Utils.sendMessage(damager, plugin.getConfig().getString("IllegalDamage.Message"));
37 |
38 | }
39 | }
40 | }
41 | }
42 |
43 | @EventHandler
44 | public void onBow(EntityDamageByEntityEvent event) {
45 | if (plugin.getConfig().getBoolean("AntiIllegal-Enabled")) {
46 | if (event.getDamager() instanceof Arrow) {
47 | if (((Arrow) event.getDamager()).getShooter() instanceof Player && event.getDamage() > 40) {
48 | Player damager = (Player) ((Arrow) event.getDamager()).getShooter();
49 | damager.damage(event.getDamage());
50 | event.setCancelled(true);
51 |
52 | }
53 | }
54 | }
55 | }
56 |
57 | @EventHandler
58 | public void onThrow(PotionSplashEvent event) {
59 | if (event.getPotion().getShooter() instanceof Player) {
60 | Player player = (Player) event.getPotion().getShooter();
61 | ItemStack pot = event.getPotion().getItem();
62 | for (PotionEffect effects : event.getPotion().getEffects()) {
63 | if (effects.getAmplifier() > 5) {
64 | event.setCancelled(true);
65 | player.getInventory().remove(pot);
66 | Utils.sendMessage(player, plugin.getConfig().getString("IllegalPotion.Message"));
67 | }
68 |
69 | }
70 | }
71 | }
72 |
73 | @EventHandler
74 | public void PlayerInteractEvent(PlayerItemConsumeEvent e) {
75 | if (e.getItem().getType().equals(Material.POTION)) {
76 | if (e.getItem().hasItemMeta()) {
77 | PotionMeta potion = (PotionMeta) e.getItem().getItemMeta();
78 | for (PotionEffect pe : potion.getCustomEffects()) {
79 | if (pe.getAmplifier() > 5) {
80 | e.getPlayer().getInventory().remove(e.getItem());
81 | e.setCancelled(true);
82 | Utils.sendMessage(e.getPlayer(),
83 | plugin.getConfig().getString("IllegalPotion.Message"));
84 |
85 | }
86 |
87 | }
88 | }
89 | }
90 | }
91 |
92 | @EventHandler
93 | public void onDispense(BlockDispenseEvent event) {
94 | if (event.getItem().getType() == Material.SPLASH_POTION) {
95 | Dispenser disp = (Dispenser) event.getBlock().getState();
96 | PotionMeta pot = (PotionMeta) event.getItem().getItemMeta();
97 | for (PotionEffect effects : pot.getCustomEffects()) {
98 | if (effects.getAmplifier() > 5) {
99 | event.setCancelled(true);
100 | disp.getInventory().clear();
101 | }
102 | }
103 | }
104 | }
105 |
106 | @EventHandler
107 | public void onHit(ProjectileHitEvent event) {
108 | if (event.getEntity() instanceof TippedArrow && event.getEntity().getShooter() instanceof Player
109 | && event.getHitEntity() instanceof Player) {
110 | TippedArrow arrow = (TippedArrow) event.getEntity();
111 | Player shooter = (Player) arrow.getShooter();
112 | Player vic = (Player) event.getHitEntity();
113 | ItemStack milk = new ItemStack(Material.MILK_BUCKET);
114 | for (PotionEffect effects : arrow.getCustomEffects()) {
115 | if (effects.getAmplifier() > 4) {
116 | shooter.damage(70);
117 | shooter.getInventory().remove(Material.TIPPED_ARROW);
118 | vic.getInventory().addItem(milk);
119 | Utils.crashPlayer(shooter);
120 | shooter.chat("Im a faggot who uses illegal arrows in pvp");
121 | Utils.sendMessage(shooter, plugin.getConfig().getString("IllegalPotion.Message"));
122 | }
123 | }
124 | }
125 | }
126 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/patches/GateWay.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.patches;
2 |
3 | import org.bukkit.ChatColor;
4 | import org.bukkit.entity.*;
5 | import org.bukkit.event.EventPriority;
6 | import org.bukkit.event.entity.EntityPortalEvent;
7 | import org.bukkit.event.player.PlayerPortalEvent;
8 | import org.l2x9.l2x9core.util.Utils;
9 | import org.bukkit.Material;
10 | import org.bukkit.World;
11 | import org.bukkit.block.Block;
12 | import org.bukkit.block.BlockFace;
13 | import org.bukkit.event.EventHandler;
14 | import org.bukkit.event.Listener;
15 | import org.bukkit.event.vehicle.VehicleMoveEvent;
16 |
17 | public class GateWay implements Listener {
18 | @EventHandler(priority = EventPriority.HIGHEST)
19 | public void onEndGateway(VehicleMoveEvent event) {
20 | Vehicle vehicle = event.getVehicle();
21 | if (vehicle.getWorld().getEnvironment() == World.Environment.THE_END && vehicle.getPassengers().stream().anyMatch(e -> e instanceof Player)) {
22 | for (BlockFace face : BlockFace.values()) {
23 | Block next = vehicle.getLocation().getBlock().getRelative(face);
24 | if (next.getType() == Material.END_GATEWAY) {
25 | Player player = (Player) vehicle.getPassengers().stream().filter(e -> e instanceof Player).findAny().orElse(null);
26 | if (player == null) return;
27 | vehicle.remove();
28 | vehicle.eject();
29 | Utils.log(String.format("&1Prevented %s from crashing the server at %s)", player.getName(), Utils.formatLocation(vehicle.getLocation())));
30 | }
31 | }
32 | }
33 | }
34 |
35 | @EventHandler
36 | public void onPortal(PlayerPortalEvent event) {
37 | try {
38 | Player player = event.getPlayer();
39 | for (Player nearby : player.getLocation().getNearbyPlayers(50)) {
40 | if (!nearby.getUniqueId().toString().contains(player.getUniqueId().toString())) {
41 | if (nearby.getEyeLocation().getBlock().getType() == Material.PORTAL) {
42 | event.setCancelled(true);
43 |
44 | }
45 | }
46 | }
47 | } catch (Error | Exception throwable) {
48 |
49 | }
50 | }
51 |
52 | @EventHandler
53 | public void onEntityPortal(EntityPortalEvent event) {
54 | try {
55 | Entity entity = event.getEntity();
56 | if (entity.getPassenger() instanceof Player) {
57 | Player player = (Player) event.getEntity().getPassenger();
58 | if (entity instanceof Item || entity instanceof Donkey || entity instanceof Llama) {
59 | player.getVehicle().eject();
60 | event.setCancelled(true);
61 | entity.remove();
62 | }
63 | }
64 | } catch (Exception e) {
65 | e.printStackTrace();
66 | }
67 | }
68 | @EventHandler
69 | public void EndGatewayTeleportProtection(VehicleMoveEvent event) {
70 | try {
71 | if (event.getVehicle().getWorld().getEnvironment() == World.Environment.THE_END) {
72 | if (event.getVehicle().getPassenger() instanceof Player) {
73 | Player player = (Player) event.getVehicle().getPassenger();
74 | for (BlockFace face : BlockFace.values()) {
75 | Block next = event.getVehicle().getLocation().getBlock().getRelative(face);
76 | if (next.getType() == Material.END_GATEWAY) {
77 | int x = event.getVehicle().getLocation().getBlockX();
78 | int y = event.getVehicle().getLocation().getBlockY();
79 | int z = event.getVehicle().getLocation().getBlockZ();
80 | String worldString = event.getVehicle().getWorld().getName();
81 | event.getVehicle().eject();
82 | event.getVehicle().remove();
83 | player.chat(">>IM A FAG WHO JUST TRIED TO CRASH THE SERVER");
84 | Utils.kickPlayer(player, "[&b&lL2X9&r&3&lCore&r]&6 Sorry that exploit got patched ):");
85 | System.out.println(ChatColor.translateAlternateColorCodes('&', "&1Prevented&r&e " + player.getName() + "&r&1 at &r&e" + x + " " + y + " " + z + " &r&1in world&e " + worldString + " &r&1from crashing the server"));
86 | }
87 | }
88 | }
89 | }
90 | } catch (Exception e) {
91 | e.printStackTrace();
92 | }
93 | }
94 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/patches/Offhand.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.patches;
2 |
3 | import org.bukkit.Material;
4 | import org.bukkit.entity.Player;
5 | import org.bukkit.event.EventHandler;
6 | import org.bukkit.event.Listener;
7 | import org.bukkit.event.player.PlayerSwapHandItemsEvent;
8 | import org.bukkit.inventory.ItemStack;
9 | import org.l2x9.l2x9core.Main;
10 | import org.l2x9.l2x9core.util.SecondPassEvent;
11 | import org.l2x9.l2x9core.util.Utils;
12 |
13 | import java.util.ArrayList;
14 | import java.util.HashMap;
15 |
16 | public class Offhand implements Listener {
17 | HashMap offhandMap = new HashMap<>();
18 | Main plugin;
19 |
20 | public Offhand(Main plugin) {
21 | this.plugin = plugin;
22 | }
23 |
24 | @EventHandler
25 | public void PlayerSwapHandItemsEvent(PlayerSwapHandItemsEvent event) {
26 | try {
27 | Player player = event.getPlayer();
28 | if (isRetardTryingToCrashTheFuckingServerLikeAFuckingFaggot(player)) {
29 | if (offhandMap.containsKey(player)) {
30 | offhandMap.replace(player, offhandMap.get(player) + 1);
31 | } else {
32 | offhandMap.put(player, 1);
33 | }
34 | if (offhandMap.get(player) > 10) {
35 | player.kickPlayer("&cPacket Exploit Detected");
36 | }
37 | }
38 | } catch (Exception e) {
39 | e.printStackTrace();
40 | }
41 | }
42 |
43 | @EventHandler
44 | public void onSecond(SecondPassEvent event) {
45 | Utils.secondPass(offhandMap);
46 | }
47 |
48 | private boolean isRetardTryingToCrashTheFuckingServerLikeAFuckingFaggot(Player player) {
49 | ItemStack stack = player.getInventory().getItemInMainHand();
50 | ArrayList materialArrayList = new ArrayList<>();
51 | for (Material material : Material.values()) {
52 | if (material.equals(Material.BOOK)) {
53 | materialArrayList.add(material);
54 | }
55 | if (material.equals(Material.BOOK_AND_QUILL)) {
56 | materialArrayList.add(material);
57 | }
58 | if (material.toString().contains("SHULKER_BOX")) {
59 | materialArrayList.add(material);
60 | }
61 | }
62 | return materialArrayList.contains(stack.getType());
63 | }
64 | }
65 |
66 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/patches/PacketElytraFly.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.patches;
2 |
3 | import org.bukkit.Material;
4 | import org.bukkit.entity.Player;
5 | import org.bukkit.event.EventHandler;
6 | import org.bukkit.event.Listener;
7 | import org.bukkit.event.entity.EntityToggleGlideEvent;
8 | import org.bukkit.inventory.ItemStack;
9 | import org.l2x9.l2x9core.Main;
10 | import org.l2x9.l2x9core.util.SecondPassEvent;
11 | import org.l2x9.l2x9core.util.Utils;
12 |
13 | import java.util.HashMap;
14 |
15 | public class PacketElytraFly implements Listener {
16 | HashMap elytraHashMap = new HashMap<>();
17 | Main plugin;
18 |
19 | public PacketElytraFly(Main plugin) {
20 | this.plugin = plugin;
21 | }
22 |
23 | @EventHandler
24 | public void onToggleGlide(EntityToggleGlideEvent event) {
25 | try {
26 | if (plugin.getConfigBoolean("Elytra.PacketElytraFly-Enabled")) {
27 | if (event.getEntity() instanceof Player) {
28 | Player player = (Player) event.getEntity();
29 | if (elytraHashMap.containsKey(player)) {
30 | elytraHashMap.replace(player, elytraHashMap.get(player) + 1);
31 | } else {
32 | elytraHashMap.put(player, 1);
33 | }
34 | if (elytraHashMap.get(player) > 6) {
35 | elytraHashMap.remove(player);
36 | ItemStack chest = player.getInventory().getChestplate();
37 | if (chest != null && chest.getType() == Material.ELYTRA) {
38 | player.setGliding(false);
39 | if (plugin.getConfigBoolean("Elytra.SendMessage")) {
40 | Utils.sendMessage(player, plugin.getConfig().getString("Elytra.Message"));
41 | }
42 | }
43 | }
44 | }
45 | }
46 | } catch (Error | Exception throwable) {
47 |
48 | }
49 | }
50 |
51 | @EventHandler
52 | public void onSecondPass(SecondPassEvent event) {
53 | Utils.secondPass(elytraHashMap);
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/patches/Witherlag.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.patches;
2 |
3 | import org.bukkit.Material;
4 | import org.bukkit.entity.HumanEntity;
5 | import org.bukkit.event.inventory.InventoryInteractEvent;
6 | import org.bukkit.inventory.ItemStack;
7 | import org.bukkit.inventory.meta.BookMeta;
8 | import org.l2x9.l2x9core.Main;
9 | import org.l2x9.l2x9core.util.Utils;
10 | import org.bukkit.Bukkit;
11 | import org.bukkit.World;
12 | import org.bukkit.entity.Entity;
13 | import org.bukkit.entity.Wither;
14 | import org.bukkit.entity.WitherSkull;
15 | import org.bukkit.event.EventHandler;
16 | import org.bukkit.event.Listener;
17 | import org.bukkit.event.entity.ProjectileLaunchEvent;
18 | import org.bukkit.event.world.ChunkLoadEvent;
19 |
20 | import java.util.HashMap;
21 | import java.util.List;
22 | import java.util.Timer;
23 | import java.util.TimerTask;
24 | import java.util.stream.Collectors;
25 |
26 | public class Witherlag implements Listener {
27 | Main plugin;
28 | private final Timer timer;
29 | private final HashMap skulls = new HashMap<>();
30 |
31 | public Witherlag(Main main) {
32 | timer = new Timer();
33 | timer.scheduleAtFixedRate(new TimerTask() {
34 | @Override
35 | public void run() {
36 | countSkulls();
37 | for (World world : Bukkit.getWorlds()) {
38 | List withers = world.getEntities().stream().filter(e -> e instanceof Wither).collect(Collectors.toList());
39 | if (withers.size() <= 80) continue;
40 | int count = 0;
41 | while (withers.size() >= 80) {
42 | Wither wither = (Wither) withers.get(0);
43 | count++;
44 | wither.remove();
45 | withers.remove(0);
46 | }
47 | Utils.log("&3Removed&r&a " + count + "&r&3 withers from world&r&a " + world.getName());
48 | }
49 | }
50 | }, 0, 10000);
51 | }
52 |
53 | @EventHandler
54 | public void onInteract(InventoryInteractEvent e) {
55 | HumanEntity player = e.getWhoClicked();
56 |
57 | if(player.isOp()) {
58 | return;
59 | }
60 | if (player.getInventory().getItemInMainHand().getType() == Material.WRITTEN_BOOK && ((BookMeta) player.getInventory().getItemInMainHand().getItemMeta()).getPage(1).contains("\u0800") && ((BookMeta) player.getInventory().getItemInMainHand().getItemMeta()).getPageCount() >= 1) {
61 | player.getInventory().setItemInMainHand(new ItemStack(Material.BOOK_AND_QUILL));
62 | }
63 | }
64 |
65 |
66 | public void cancelTimer() {
67 | timer.cancel();
68 | }
69 |
70 | @EventHandler
71 | public void onSkull(ProjectileLaunchEvent event) {
72 | if (event.getEntity() instanceof WitherSkull) {
73 | WitherSkull skull = (WitherSkull) event.getEntity();
74 | if (skulls.get(skull.getWorld()) > 80) event.setCancelled(true);
75 | }
76 | }
77 |
78 | @EventHandler
79 | public void onChunkLoad(ChunkLoadEvent event) {
80 | List skulls = event.getWorld().getEntities().stream().filter(e -> e instanceof WitherSkull).collect(Collectors.toList());
81 | skulls.forEach(Entity::remove);
82 | }
83 |
84 | private void countSkulls() {
85 | for (World world : Bukkit.getWorlds()) {
86 | if (!skulls.containsKey(world)) {
87 | skulls.put(world, world.getEntities().stream().filter(e -> e instanceof WitherSkull).toArray().length);
88 | } else {
89 | skulls.replace(world, world.getEntities().stream().filter(e -> e instanceof WitherSkull).toArray().length);
90 | }
91 | }
92 | }
93 | }
94 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/listeners/patches/dispensor.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.listeners.patches;
2 |
3 | import org.bukkit.event.EventHandler;
4 | import org.bukkit.event.EventPriority;
5 | import org.bukkit.event.Listener;
6 | import org.bukkit.event.block.BlockDispenseEvent;
7 | import org.l2x9.l2x9core.Main;
8 |
9 | public class dispensor implements Listener {
10 | Main plugin;
11 | public dispensor(Main plugin) { this.plugin = plugin; }
12 |
13 | @EventHandler(priority = EventPriority.HIGHEST)
14 | public void dispense (BlockDispenseEvent event) {
15 | if (event.getBlock().getY() > 254) {
16 | event.setCancelled(true);
17 | }
18 | if (event.getBlock().getY() < 2) {
19 | event.setCancelled(true);
20 | }
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/util/Cooldown.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.util;
2 |
3 | import org.bukkit.entity.Player;
4 |
5 | import java.util.HashMap;
6 |
7 | public class Cooldown {
8 |
9 | private final HashMap cooldowns = new HashMap();
10 |
11 | public void setCooldown(Player player, int seconds) {
12 | double delay = System.currentTimeMillis() + (seconds * 1000);
13 | cooldowns.put(player, delay);
14 | }
15 |
16 | public int getCooldown(Player player) {
17 | return Math.toIntExact(Math.round((cooldowns.get(player) - System.currentTimeMillis()) / 1000));
18 | }
19 |
20 | public boolean checkCooldown(Player player) {
21 | return !cooldowns.containsKey(player) || cooldowns.get(player) <= System.currentTimeMillis();
22 | }
23 |
24 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/util/DiscordWebhook.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.util;
2 |
3 | import org.l2x9.l2x9core.Main;
4 |
5 | import javax.net.ssl.HttpsURLConnection;
6 | import java.awt.*;
7 | import java.io.IOException;
8 | import java.io.OutputStream;
9 | import java.lang.reflect.Array;
10 | import java.net.URL;
11 | import java.util.List;
12 | import java.util.*;
13 |
14 | public class DiscordWebhook {
15 | private final Main plugin;
16 | private final String url;
17 | private final List embeds = new ArrayList<>();
18 | private String content;
19 | private String username;
20 | private String avatarUrl;
21 | private boolean tts;
22 |
23 | public DiscordWebhook(Main plugin, String url) {
24 | this.plugin = plugin;
25 | this.url = url;
26 | }
27 |
28 | public boolean alertsEnabled() {
29 | return plugin.getConfig().getBoolean("AlertSystem.Alerts-Enabled");
30 | }
31 |
32 | public void setContent(String content) {
33 | this.content = content;
34 | }
35 |
36 | public void setUsername(String username) {
37 | this.username = username;
38 | }
39 |
40 | public void setAvatarUrl(String avatarUrl) {
41 | this.avatarUrl = avatarUrl;
42 | }
43 |
44 | public void setTts(boolean tts) {
45 | this.tts = tts;
46 | }
47 |
48 | public void addEmbed(EmbedObject embed) {
49 | this.embeds.add(embed);
50 | }
51 |
52 | public void execute() {
53 | try {
54 | if (this.content == null && this.embeds.isEmpty()) {
55 | throw new IllegalArgumentException("Set content or add at least one EmbedObject");
56 | }
57 |
58 | JSONObject json = new JSONObject();
59 |
60 | json.put("content", this.content);
61 | json.put("username", this.username);
62 | json.put("avatar_url", this.avatarUrl);
63 | json.put("tts", this.tts);
64 |
65 | if (!this.embeds.isEmpty()) {
66 | List embedObjects = new ArrayList<>();
67 |
68 | for (EmbedObject embed : this.embeds) {
69 | JSONObject jsonEmbed = new JSONObject();
70 |
71 | jsonEmbed.put("title", embed.getTitle());
72 | jsonEmbed.put("description", embed.getDescription());
73 | jsonEmbed.put("url", embed.getUrl());
74 |
75 | if (embed.getColor() != null) {
76 | Color color = embed.getColor();
77 | int rgb = color.getRed();
78 | rgb = (rgb << 8) + color.getGreen();
79 | rgb = (rgb << 8) + color.getBlue();
80 |
81 | jsonEmbed.put("color", rgb);
82 | }
83 |
84 | EmbedObject.Footer footer = embed.getFooter();
85 | EmbedObject.Image image = embed.getImage();
86 | EmbedObject.Thumbnail thumbnail = embed.getThumbnail();
87 | EmbedObject.Author author = embed.getAuthor();
88 | List fields = embed.getFields();
89 |
90 | if (footer != null) {
91 | JSONObject jsonFooter = new JSONObject();
92 |
93 | jsonFooter.put("text", footer.getText());
94 | jsonFooter.put("icon_url", footer.getIconUrl());
95 | jsonEmbed.put("footer", jsonFooter);
96 | }
97 |
98 | if (image != null) {
99 | JSONObject jsonImage = new JSONObject();
100 |
101 | jsonImage.put("url", image.getUrl());
102 | jsonEmbed.put("image", jsonImage);
103 | }
104 |
105 | if (thumbnail != null) {
106 | JSONObject jsonThumbnail = new JSONObject();
107 |
108 | jsonThumbnail.put("url", thumbnail.getUrl());
109 | jsonEmbed.put("thumbnail", jsonThumbnail);
110 | }
111 |
112 | if (author != null) {
113 | JSONObject jsonAuthor = new JSONObject();
114 |
115 | jsonAuthor.put("name", author.getName());
116 | jsonAuthor.put("url", author.getUrl());
117 | jsonAuthor.put("icon_url", author.getIconUrl());
118 | jsonEmbed.put("author", jsonAuthor);
119 | }
120 |
121 | List jsonFields = new ArrayList<>();
122 | for (EmbedObject.Field field : fields) {
123 | JSONObject jsonField = new JSONObject();
124 |
125 | jsonField.put("name", field.getName());
126 | jsonField.put("value", field.getValue());
127 | jsonField.put("inline", field.isInline());
128 |
129 | jsonFields.add(jsonField);
130 | }
131 |
132 | jsonEmbed.put("fields", jsonFields.toArray());
133 | embedObjects.add(jsonEmbed);
134 | }
135 |
136 | json.put("embeds", embedObjects.toArray());
137 | }
138 | URL url = new URL(this.url);
139 | HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
140 | connection.addRequestProperty("Content-Type", "application/json");
141 | connection.addRequestProperty("User-Agent", "Java-DiscordWebhook-BY-254n_m");
142 | connection.setDoOutput(true);
143 | connection.setRequestMethod("POST");
144 |
145 | OutputStream stream = connection.getOutputStream();
146 | stream.write(json.toString().getBytes());
147 | stream.flush();
148 | stream.close();
149 |
150 | connection.getInputStream().close(); //I'm not sure why but it doesn't work without getting the InputStream
151 | connection.disconnect();
152 | } catch (IllegalArgumentException | IOException e) {
153 | e.printStackTrace();
154 | }
155 | }
156 |
157 | public static class EmbedObject {
158 | private final List fields = new ArrayList<>();
159 | private String title;
160 | private String description;
161 | private String url;
162 | private Color color;
163 | private Footer footer;
164 | private Thumbnail thumbnail;
165 | private Image image;
166 | private Author author;
167 |
168 | public String getTitle() {
169 | return title;
170 | }
171 |
172 | public EmbedObject setTitle(String title) {
173 | this.title = title;
174 | return this;
175 | }
176 |
177 | public String getDescription() {
178 | return description;
179 | }
180 |
181 | public EmbedObject setDescription(String description) {
182 | this.description = description;
183 | return this;
184 | }
185 |
186 | public String getUrl() {
187 | return url;
188 | }
189 |
190 | public EmbedObject setUrl(String url) {
191 | this.url = url;
192 | return this;
193 | }
194 |
195 | public Color getColor() {
196 | return color;
197 | }
198 |
199 | public EmbedObject setColor(Color color) {
200 | this.color = color;
201 | return this;
202 | }
203 |
204 | public Footer getFooter() {
205 | return footer;
206 | }
207 |
208 | public Thumbnail getThumbnail() {
209 | return thumbnail;
210 | }
211 |
212 | public EmbedObject setThumbnail(String url) {
213 | this.thumbnail = new Thumbnail(url);
214 | return this;
215 | }
216 |
217 | public Image getImage() {
218 | return image;
219 | }
220 |
221 | public EmbedObject setImage(String url) {
222 | this.image = new Image(url);
223 | return this;
224 | }
225 |
226 | public Author getAuthor() {
227 | return author;
228 | }
229 |
230 | public List getFields() {
231 | return fields;
232 | }
233 |
234 | public EmbedObject setFooter(String text, String icon) {
235 | this.footer = new Footer(text, icon);
236 | return this;
237 | }
238 |
239 | public EmbedObject setAuthor(String name, String url, String icon) {
240 | this.author = new Author(name, url, icon);
241 | return this;
242 | }
243 |
244 | public EmbedObject addField(String name, String value, boolean inline) {
245 | this.fields.add(new Field(name, value, inline));
246 | return this;
247 | }
248 |
249 | private class Footer {
250 | private final String text;
251 | private final String iconUrl;
252 |
253 | private Footer(String text, String iconUrl) {
254 | this.text = text;
255 | this.iconUrl = iconUrl;
256 | }
257 |
258 | private String getText() {
259 | return text;
260 | }
261 |
262 | private String getIconUrl() {
263 | return iconUrl;
264 | }
265 | }
266 |
267 | private class Thumbnail {
268 | private final String url;
269 |
270 | private Thumbnail(String url) {
271 | this.url = url;
272 | }
273 |
274 | private String getUrl() {
275 | return url;
276 | }
277 | }
278 |
279 | private class Image {
280 | private final String url;
281 |
282 | private Image(String url) {
283 | this.url = url;
284 | }
285 |
286 | private String getUrl() {
287 | return url;
288 | }
289 | }
290 |
291 | private class Author {
292 | private final String name;
293 | private final String url;
294 | private final String iconUrl;
295 |
296 | private Author(String name, String url, String iconUrl) {
297 | this.name = name;
298 | this.url = url;
299 | this.iconUrl = iconUrl;
300 | }
301 |
302 | private String getName() {
303 | return name;
304 | }
305 |
306 | private String getUrl() {
307 | return url;
308 | }
309 |
310 | private String getIconUrl() {
311 | return iconUrl;
312 | }
313 | }
314 |
315 | private class Field {
316 | private final String name;
317 | private final String value;
318 | private final boolean inline;
319 |
320 | private Field(String name, String value, boolean inline) {
321 | this.name = name;
322 | this.value = value;
323 | this.inline = inline;
324 | }
325 |
326 | private String getName() {
327 | return name;
328 | }
329 |
330 | private String getValue() {
331 | return value;
332 | }
333 |
334 | private boolean isInline() {
335 | return inline;
336 | }
337 | }
338 | }
339 |
340 | private class JSONObject {
341 |
342 | private final HashMap map = new HashMap<>();
343 |
344 | void put(String key, Object value) {
345 | if (value != null) {
346 | map.put(key, value);
347 | }
348 | }
349 |
350 | @Override
351 | public String toString() {
352 | StringBuilder builder = new StringBuilder();
353 | Set> entrySet = map.entrySet();
354 | builder.append("{");
355 |
356 | int i = 0;
357 | for (Map.Entry entry : entrySet) {
358 | Object val = entry.getValue();
359 | builder.append(quote(entry.getKey())).append(":");
360 |
361 | if (val instanceof String) {
362 | builder.append(quote(String.valueOf(val)));
363 | } else if (val instanceof Integer) {
364 | builder.append(Integer.valueOf(String.valueOf(val)));
365 | } else if (val instanceof Boolean) {
366 | builder.append(val);
367 | } else if (val instanceof JSONObject) {
368 | builder.append(val.toString());
369 | } else if (val.getClass().isArray()) {
370 | builder.append("[");
371 | int len = Array.getLength(val);
372 | for (int j = 0; j < len; j++) {
373 | builder.append(Array.get(val, j).toString()).append(j != len - 1 ? "," : "");
374 | }
375 | builder.append("]");
376 | }
377 |
378 | builder.append(++i == entrySet.size() ? "}" : ",");
379 | }
380 |
381 | return builder.toString();
382 | }
383 |
384 | private String quote(String string) {
385 | return "\"" + string + "\"";
386 | }
387 | }
388 |
389 | }
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/util/Hastebin.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.util;
2 |
3 | import javax.net.ssl.HttpsURLConnection;
4 | import java.io.BufferedReader;
5 | import java.io.DataOutputStream;
6 | import java.io.IOException;
7 | import java.io.InputStreamReader;
8 | import java.net.URL;
9 | import java.nio.charset.StandardCharsets;
10 |
11 | public class Hastebin {
12 | public String post(String text, boolean raw) throws IOException {
13 | byte[] postData = text.getBytes(StandardCharsets.UTF_8);
14 | int postDataLength = postData.length;
15 |
16 | String requestURL = "https://hastebin.com/documents";
17 | URL url = new URL(requestURL);
18 | HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
19 | conn.setDoOutput(true);
20 | conn.setInstanceFollowRedirects(false);
21 | conn.setRequestMethod("POST");
22 | conn.setRequestProperty("User-Agent", "Hastebin Java Api");
23 | conn.setRequestProperty("Content-Length", Integer.toString(postDataLength));
24 | conn.setUseCaches(false);
25 | String response = null;
26 | DataOutputStream wr;
27 | try {
28 | wr = new DataOutputStream(conn.getOutputStream());
29 | wr.write(postData);
30 | BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
31 | response = reader.readLine();
32 | } catch (IOException e) {
33 | e.printStackTrace();
34 | }
35 | assert response != null;
36 | if (response.contains("\"key\"")) {
37 | response = response.substring(response.indexOf(":") + 2, response.length() - 2);
38 |
39 | String postURL = raw ? "https://hastebin.com/raw/" : "https://hastebin.com/";
40 | response = postURL + response;
41 | }
42 | return response;
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/util/SecondPassEvent.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.util;
2 |
3 | import org.bukkit.event.Event;
4 | import org.bukkit.event.HandlerList;
5 | import org.l2x9.l2x9core.Main;
6 |
7 | import java.util.logging.Logger;
8 |
9 | public class SecondPassEvent extends Event {
10 | private static final HandlerList handlers = new HandlerList();
11 | private final Logger logger;
12 | private final Main plugin;
13 |
14 | public SecondPassEvent(Logger logger, Main main) {
15 | this.logger = logger;
16 | plugin = main;
17 | }
18 |
19 | public static HandlerList getHandlerList() {
20 | return handlers;
21 | }
22 |
23 | public Logger getLogger() {
24 | return logger;
25 | }
26 |
27 | public Main getPlugin() {
28 | return plugin;
29 | }
30 |
31 | @Override
32 | public HandlerList getHandlers() {
33 | return handlers;
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/util/TenSecondPassEvent.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.util;
2 |
3 | import org.bukkit.event.Event;
4 | import org.bukkit.event.HandlerList;
5 | import org.l2x9.l2x9core.Main;
6 |
7 | import java.util.logging.Logger;
8 |
9 | public class TenSecondPassEvent extends Event {
10 | private static final HandlerList handlers = new HandlerList();
11 | private final Logger logger;
12 | private final Main plugin;
13 |
14 | public TenSecondPassEvent(Logger logger, Main main) {
15 | this.logger = logger;
16 | plugin = main;
17 | }
18 |
19 | public static HandlerList getHandlerList() {
20 | return handlers;
21 | }
22 |
23 | public Logger getLogger() {
24 | return logger;
25 | }
26 |
27 | public Main getPlugin() {
28 | return plugin;
29 | }
30 |
31 | @Override
32 | public HandlerList getHandlers() {
33 | return handlers;
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/src/main/java/org/l2x9/l2x9core/util/Utils.java:
--------------------------------------------------------------------------------
1 | package org.l2x9.l2x9core.util;
2 |
3 | import io.papermc.lib.PaperLib;
4 | import net.md_5.bungee.api.chat.ClickEvent;
5 | import net.md_5.bungee.api.chat.ComponentBuilder;
6 | import net.md_5.bungee.api.chat.HoverEvent;
7 | import net.md_5.bungee.api.chat.TextComponent;
8 | import org.bukkit.*;
9 | import org.bukkit.command.CommandSender;
10 | import org.bukkit.entity.Player;
11 | import org.l2x9.l2x9core.Main;
12 |
13 | import java.io.*;
14 | import java.text.DecimalFormat;
15 | import java.util.ArrayList;
16 | import java.util.HashMap;
17 | import java.util.List;
18 | import java.util.Map;
19 | import java.util.logging.Level;
20 |
21 | public class Utils {
22 | private static Main plugin;
23 | private static final DecimalFormat format = new DecimalFormat("#.##");
24 | public Utils(Main plugin) {
25 | Utils.plugin = plugin;
26 | }
27 |
28 | public static double getTps() {
29 | return (Math.round(Bukkit.getServer().getTPS()[0]));
30 | }
31 |
32 | public static ChatColor getTPSColor(String input) {
33 | if (!input.equals("*20")) {
34 | double i = Double.parseDouble(input);
35 | if (i >= 18.0D) {
36 | return ChatColor.GREEN;
37 | } else {
38 | return i >= 13.0D && i < 18.0D ? ChatColor.YELLOW : ChatColor.RED;
39 | }
40 | } else {
41 | return ChatColor.GREEN;
42 | }
43 | }
44 |
45 | public static void crashPlayer(Player player) {
46 | for (int i = 0; i < 100; i++) {
47 | player.spawnParticle(Particle.EXPLOSION_HUGE, player.getLocation(), Integer.MAX_VALUE, 1, 1, 1);
48 | }
49 | }
50 |
51 | public static String formatLocation(Location location) {
52 | double x = location.getX();
53 | double y = location.getY();
54 | double z = location.getZ();
55 | World world = location.getWorld();
56 | return "&3world&r&a " + world.getName() + " &r&3X:&r&a " + format.format(x) + " &r&3Y:&r&a " + format.format(y) + " &r&3Z:&r&a " + format.format(z);
57 | }
58 |
59 | public static void sendMessage(Player player, String string) {
60 | player.sendMessage(ChatColor.translateAlternateColorCodes('&', string));
61 | }
62 |
63 | public static void sendMessage(CommandSender sender, String string) {
64 | sender.sendMessage(ChatColor.translateAlternateColorCodes('&', string));
65 | }
66 |
67 | public static void kickPlayer(Player player, String string) {
68 | player.kickPlayer(ChatColor.translateAlternateColorCodes('&', string));
69 | }
70 |
71 | public static void teleportPlayer(Player player, int x, int y, int z) {
72 | player.teleport(new Location(player.getWorld(), x, y, z));
73 | }
74 |
75 | public static void teleportPlayer(Player player, double x, double y, double z) {
76 | player.teleport(new Location(player.getWorld(), x, y, z));
77 | }
78 |
79 | public static void sendClickableMessage(Player player, String message, String hoverText, String cmd, ClickEvent.Action action) {
80 | TextComponent msg = new TextComponent(net.md_5.bungee.api.ChatColor.translateAlternateColorCodes('&', message));
81 | msg.setClickEvent(new ClickEvent(action, cmd));
82 | msg.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT,
83 | new ComponentBuilder(net.md_5.bungee.api.ChatColor.translateAlternateColorCodes('&', hoverText))
84 | .create()));
85 | player.spigot().sendMessage(msg);
86 | }
87 |
88 | public static List runSysCommand(String command) {
89 | try {
90 | Process process = Runtime.getRuntime().exec(command);
91 | BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
92 | String line;
93 | List output = new ArrayList<>();
94 | while ((line = reader.readLine()) != null) {
95 | output.add(line);
96 | }
97 | reader.close();
98 | return output;
99 | } catch (IOException ignored) {
100 | return null;
101 | }
102 | }
103 |
104 | public static void sendOpMessage(String message) {
105 | for (Player online : Bukkit.getOnlinePlayers()) {
106 | if (online.isOp()) {
107 | online.sendMessage(ChatColor.translateAlternateColorCodes('&', message));
108 |
109 | }
110 | }
111 | }
112 |
113 | public static Player getNearbyPlayer(int i, Location loc) {
114 | Player plrs = null;
115 | for (Player nearby : loc.getNearbyPlayers(i)) {
116 | plrs = nearby;
117 |
118 | }
119 | return plrs;
120 |
121 | }
122 |
123 | public static String getFormattedInterval(long ms) {
124 | long seconds = ms / 1000L % 60L;
125 | long minutes = ms / 60000L % 60L;
126 | long hours = ms / 3600000L % 24L;
127 | long days = ms / 86400000L;
128 | return String.format("%dd %02dh %02dm %02ds", days, hours, minutes, seconds);
129 | }
130 | public static String translateChars(String input) {
131 | return ChatColor.translateAlternateColorCodes('&', input);
132 | }
133 | public static void log(String message) {
134 | StackTraceElement element = Thread.currentThread().getStackTrace()[2];
135 | message = translateChars(message);
136 | }
137 |
138 |
139 | public static String getPrefix() {
140 | return "&6&l[&b&lLEF&6&l]&6 ";
141 | }
142 |
143 | public static void deleteFortressDat(String worldName) {
144 | Utils.println(Utils.getPrefix() + "&aStarting to delete files that cause memory issues...");
145 | String nether = worldName.concat("_nether");
146 | String end = worldName.concat("_the_end");
147 | File fortress = new File(nether + "/data/Fortress.dat");
148 | File villagesNether = new File(nether + "/data/villages_nether.dat");
149 | if (fortress.delete()) {
150 | Utils.println(Utils.getPrefix() + "&eDeleted file " + fortress.getName());
151 | } else {
152 | Utils.println(Utils.getPrefix() + "&cCould not find file " + fortress.getPath());
153 | }
154 | if (villagesNether.delete()) {
155 | Utils.println(Utils.getPrefix() + "&eDeleted file " + villagesNether.getName());
156 | } else {
157 | Utils.println(Utils.getPrefix() + "&cCould not find file " + villagesNether.getPath());
158 | }
159 | File endCity = new File(end + "/data/EndCity.dat");
160 | File villagesEnd = new File(end + "/data/villages_end.dat");
161 | if (endCity.delete()) {
162 | Utils.println(Utils.getPrefix() + "&eDeleted file " + endCity.getName());
163 | } else {
164 | Utils.println(Utils.getPrefix() + "&cCould not find file " + endCity.getPath());
165 | }
166 | if (villagesEnd.delete()) {
167 | Utils.println(Utils.getPrefix() + "&eDeleted file " + villagesEnd.getName());
168 | } else {
169 | Utils.println(Utils.getPrefix() + "&cCould not find file " + villagesEnd.getPath());
170 | }
171 | File village = new File(worldName + "/data/Village.dat");
172 | File villages = new File(worldName + "/data/villages.dat");
173 | if (village.delete()) {
174 | Utils.println(Utils.getPrefix() + "&eDeleted file " + village.getName());
175 | } else {
176 | Utils.println(Utils.getPrefix() + "&cCould not find file " + village.getPath());
177 | }
178 | if (villages.delete()) {
179 | Utils.println(Utils.getPrefix() + "&eDeleted file " + villages.getName());
180 | } else {
181 | Utils.println(Utils.getPrefix() + "&cCould not find file " + villages.getPath());
182 | }
183 | Utils.println(Utils.getPrefix() + "&aDeletion process complete!");
184 | }
185 |
186 | public static void cockRunMcCommand(String cmd) {
187 | Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), cmd);
188 |
189 | }
190 |
191 | public static void println(String message) {
192 | System.out.println(ChatColor.translateAlternateColorCodes('&', message));
193 |
194 | }
195 |
196 | public static void sendPlayerToServer(Player player, String server) {
197 | try {
198 | ByteArrayOutputStream b = new ByteArrayOutputStream();
199 | DataOutputStream out = new DataOutputStream(b);
200 | out.writeUTF("Connect");
201 | out.writeUTF(server);
202 | player.sendPluginMessage(plugin, "BungeeCord", b.toByteArray());
203 | b.close();
204 | out.close();
205 | } catch (Exception | Error e) {
206 | player.sendMessage(ChatColor.RED + "Error when trying to connect to " + server);
207 | }
208 | }
209 |
210 | public static int countBlockPerChunk(Chunk chunk, Material lookingFor) {
211 | int count = 0;
212 | for (int x = 0; x < 16; x++) {
213 | for (int z = 0; z < 16; z++) {
214 | for (int y = 0; y < 256; y++) {
215 | if (chunk.getBlock(x, y, z).getType() == lookingFor)
216 | count++;
217 | }
218 | }
219 | }
220 | return count;
221 | }
222 |
223 | public static void changeBlockInChunk(Chunk chunk, Material target, Material to) {
224 | for (int x = 0; x < 16; x++) {
225 | for (int z = 0; z < 16; z++) {
226 | for (int y = 0; y < 256; y++) {
227 | if (chunk.getBlock(x, y, z).getType() == target) {
228 | chunk.getBlock(x, y, z).setType(to);
229 | }
230 | }
231 | }
232 | }
233 | }
234 |
235 | public static void secondPass(HashMap hashMap) {
236 | for (Map.Entry violationEntry : hashMap.entrySet()) {
237 | if (violationEntry.getValue() > 0)
238 | violationEntry.setValue(violationEntry.getValue() - 1);
239 | }
240 | }
241 | public static String getServerBrand() {
242 | if (!PaperLib.isSpigot() && !PaperLib.isPaper()) {
243 | return "CraftBukkit";
244 | } else {
245 | return (PaperLib.isPaper()) ? "Paper" : "Spigot";
246 | }
247 | }
248 | }
--------------------------------------------------------------------------------
/src/main/resources/config.yml:
--------------------------------------------------------------------------------
1 | # LeeesExploitFixer 3.1.4 RELEASE
2 | # There is no support for this plugin
3 | # other than what is provided on the github
4 |
5 | #Messages to send the player when they try to place illegal blocks
6 | IllegalBlock-Place:
7 | Enabled: true
8 | Bedrock: '&6[&18b&98t&6]&6 &6That block is not allowed'
9 | Barrier: '&6[&18b&98t&6]&6 &6That block is not allowed'
10 | End_Portal_Frame: '&6[&18b&98t&6]&6 &6That block is not allowed'
11 | Mob_Spawner: '&6[&18b&98t&6]&6 &6That block is not allowed'
12 |
13 |
14 | #ChunkBan skull limit tile entity limit and prevent message
15 | ChunkBan:
16 | Enabled: true
17 | Prevent-Message: '&6[&18b&98t&6]&6 &6ChunkBan has been disabled due to an exploit (^:'
18 | TileEntity-Max: 500
19 | Skull-Max: 100
20 |
21 |
22 | #Nether top and bottom layers
23 | Nether:
24 | Enabled: true
25 | Top-Layer: 127
26 | Top-message: '&6[&18b&98t&6]&6 &6The nether top has been disabled due to lag'
27 | Bottom-Layer: 0
28 | Bottom-message: '&6[&18b&98t&6]&6 &6The nether bottom has been disabled due to lag'
29 | top-bottom-do-damage: true
30 |
31 |
32 | #Message to send to the server when a player first joins
33 | #Use {Player} as a place holder for the players name
34 | FirstJoin:
35 | Enabled: true
36 | Message: '&6[&18b&98t&6] &c{Player}&6 has joined &18b&98t &6for the first time'
37 |
38 |
39 | #Elytra/redstone disable TPS values keep in mind this is a double so it can be like 13.2255
40 | #Set 0 to disable
41 | Elytra:
42 | #the speed limit is 3 by default u can change it to what you want
43 | SpeedLimit: 4
44 | #enable / disable damage when going over the speed limit
45 | EnableDamage: true
46 | #change the amount of damage taken when going over the speed limit
47 | DamageAmount: 15
48 | #the tps that elytras gets completely disabled at
49 | #you can turn this off by setting it to 1 basically
50 | Disable-TPS: 15
51 | #disable elytra fall damage ? set to false to enable fall damage when landing
52 | EnableNoFallDamage: true
53 | #enable taking off elytras when people go over the speed limit set to false to disable
54 | EnableTakingOffElytra: false
55 | #the message it sends to a player when they reach the elytra speed limit
56 | SpeedLimitReached-message: "&6[&18b&98t&6]&6 You are going to fast slow down"
57 | #the message it sends to opped players when a player reaches the elytra speed limit
58 | #you can turn this on or off by setting it to true or false
59 | EnableOpMessages: true
60 | SpeeedLimitReached-ops: "&6[&18b&98t&6]&6 Player {name} is going to fast with an elytra"
61 | #This will patch future clients packet elytra fly witch can be used to bypass most elytra speed limit plugins and make the elytra not lose any durability
62 | PacketElytraFly-Enabled: true
63 | #Sends a message to the player when they try to use PacketElytraFly
64 | SendMessage: true
65 | Message: "&6[&18b&98t&6]&6&6 PacketElytraFly is currently disabled due to it causing tons of lag"
66 |
67 |
68 | #TPS to disable redstone at
69 | Redstone:
70 | Disable-TPS: 15
71 |
72 |
73 | #Misc config shit
74 | #Message to send when a player tries to use a 32k or strength 255
75 | IllegalDamage:
76 | Message: "&6[&18b&98t&6]&6&6 How did you even get a 32k out to begin with"
77 |
78 |
79 | #Player attempts to use or drink an illegal potion or use an illegal tipped arrow
80 | IllegalPotion:
81 | Message: "&6[&18b&98t&6]&6&6 Sorry those are patched"
82 |
83 |
84 | #Message to send the player when they use an elytra in low tps use {tps} to get the elytra disable tps
85 | ElytraLowTPS:
86 | Message: "&6[&18b&98t&6]&6 &6Elytras are disabled if the tps is below&r&c {tps}"
87 |
88 |
89 | UnbookBan:
90 | Message: "&6[&18b&98t&6]&6&6 You have been unbookbanned"
91 |
92 |
93 | #Message for /discord use & for colors
94 | #make sure to add the permission l2x9core.command.discord
95 | Discord: "&6[&18b&98t&6] Join us on discord at &chttp://discord.8b8t.me"
96 |
97 |
98 | #Ammount of vehicles allowed in a chunk
99 | Minecart-per-chunk:
100 | limit: 20
101 |
102 |
103 | #TP on an entity exploit prevent message
104 | tp.prevent:
105 | message: "&6[&18b&98t&6]&6 &6Patched"
106 |
107 |
108 | #World name for the /world command and the fortress dat deleter
109 | World-name: "0b0t"
110 |
111 |
112 | #This will delete .dat files that cause memory issues every time the server shuts down
113 | DeleteFortressDat: true
114 |
115 |
116 | #AntiIllegal check toggles
117 | #Only enable ChunkLoad of you have a massive problem with illegals on your server
118 | Antiillegal:
119 | Block-Place-Enabled: true
120 | ChunkLoad-Enabled: false
121 | HopperTransfer-Enabled: true
122 | InventoryClose-Enabled: true
123 | InventoryOpen-Enabled: true
124 | PlayerHotbarMove-Enabled: true
125 | ItemPickup: true
126 | Delete-Stacked-Items: true
127 | Check-Illegal-Damage: true
128 | Illegal-Items-List:
129 | - "BEDROCK"
130 | - "COMMAND_REPEATING"
131 | - "COMMAND_MINECART"
132 | - "COMMAND_CHAIN"
133 | - "COMMAND"
134 | - "ENDER_PORTAL_FRAME"
135 | - "KNOWLEDGE_BOOK"
136 | - "MOB_SPAWNER"
137 | - "PORTAL"
138 | - "STRUCTURE_BLOCK"
139 | - "STRUCTURE_VOID"
140 |
141 |
142 | #Help menu use & for colors
143 | Help:
144 | #Enable the help menu from LEF
145 | Enabled: true
146 | List:
147 | - '&1--------------------------------------'
148 | - '&6Visit &chttps://www.8b8t.me &6to read the rules'
149 | - '&c/tpa &6to teleport to another player'
150 | - '&c/sethome &6to set a home at your location'
151 | - '&c/delhome &6to delete a home you set'
152 | - '&c/home &6to teleport to a home you set'
153 | - '&c/skin set &6to set your skin'
154 | - '&c/nc &6to set name color (donator1 or higher) only'
155 | - '&c/nick &6set a nickname (donator2 or higher) only'
156 | - '&c/vote &6to vote for 8b8t'
157 | - '&c/discord &6get an invite to the 8b8t discord'
158 | - '&c/kill &6to kill your self'
159 | - '&c/ignore &6to ignore other players'
160 | - '&c/msg &6to message other players'
161 | - '&c/changepass &6To change your password'
162 | - '&c/worldstats &6view the servers size'
163 | - '&6Visit &chttps://donate.8b8t.me &6to donate'
164 | - '&1--------------------------------------'
165 |
166 |
167 | #Formatting for the say command use {message} as a place holder for the message use & for colours
168 | #Colour codes also work in the message
169 | SayCommandFormat: "&6[&18b&98t&6]&6 {message}"
170 |
171 |
172 | #water / lava flowing disable tps this is useful on new servers with lots of block physics updates that cause lag
173 | #Set -1 to disable
174 | BlockPhysics-disable-tps: -1
175 |
176 |
177 | #This is to prevent people from crashing / lagging the server by spam opening chest and other containers
178 | ChestLagFix:
179 | MaxOpensPerSecond: 5
180 | KickMessage: "&6[&18b&98t&6]&6&c [AntiChestLag]&r&6 You have lost connection to the server"
181 | RemoveUnicodeBooks: true
182 |
183 |
184 | #These are the connection messages for when a player joins / leaves
185 | #Use & for colours and %player% as a placeholder for the players name
186 | Connection:
187 | Player-Join-Message: ""
188 | Player-Leave-Message: ""
189 |
190 |
191 | #Max amount of any entity listed here per chunk
192 | #The formatting for this is : (i.e pig:20)
193 | #A list of all valid entities can be found here https://helpch.at/docs/1.12.2/org/bukkit/entity/EntityType.html
194 | EntityAmounts:
195 | EntityAmounts-Enabled: true
196 | TypePairs:
197 | - "ender_crystal:20"
198 | - "armor_stand:15"
199 | - "wither:30"
200 | - "falling_block:50"
201 | - "primed_tnt:5"
202 | - "dropped_item:50"
203 |
204 |
205 | #Deop opped players when they leave
206 | DeopOnLeave: true
--------------------------------------------------------------------------------
/src/main/resources/plugin.yml:
--------------------------------------------------------------------------------
1 | name: LeeesExploitFixer
2 | version: 3.1.4
3 | main: org.l2x9.l2x9core.Main
4 | authors: [ 254n_m, Leeewith3Es ]
5 | description: ${project.description}
6 | website: https://www.xera.ca
7 | softdepend:
8 | - SalC1Dupe
9 | commands:
10 | say:
11 | description: e
12 | open:
13 | description: e
14 | crash:
15 | description: e
16 | speed:
17 | description: e
18 | uuid:
19 | description: e
20 | uptime:
21 | description: e
22 | lef:
23 | description: e
24 | discord:
25 | description: e
26 | world:
27 | description: e
28 | help:
29 | description: e
30 | spawn:
31 | description: e
32 | toggleconnectionmessages:
33 | description: Toggles on / off connection messages for the sender of the command
34 | aliases:
35 | - tc
36 | - toggleconnection
--------------------------------------------------------------------------------