Plexus/Plex
1
0
Fork 0
mirror of https://github.com/plexusorg/Plex.git synced 2025-07-14 01:18:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

API 👀

Browse Source
This commit is contained in:
Telesphoreo
2022-04-09 23:51:27 -05:00
parent de20747d45
commit 9849003ecc
323 changed files with 670 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
src/main/java/dev/plex/services/AbstractService.java
View File

@ -1,31 +0,0 @@
package dev.plex.services;
import dev.plex.PlexBase;
import lombok.Getter;
import lombok.Setter;
@Getter
public abstract class AbstractService extends PlexBase implements IService
{
private boolean asynchronous;
private boolean repeating;
@Setter
private int taskId;
public AbstractService(boolean repeating, boolean async)
{
this.repeating = repeating;
this.asynchronous = async;
}
public void onStart()
{
}
public void onEnd()
{
}
}

8
src/main/java/dev/plex/services/IService.java
View File

@ -1,8 +0,0 @@
package dev.plex.services;
public interface IService
{
void run();
int repeatInSeconds();
}

99
src/main/java/dev/plex/services/ServiceManager.java
View File

@ -1,99 +0,0 @@
package dev.plex.services;
import com.google.common.collect.Lists;
import dev.plex.Plex;
import dev.plex.services.impl.*;
import org.bukkit.Bukkit;
import org.bukkit.scheduler.BukkitTask;
import java.util.List;
public class ServiceManager
{
private final List<AbstractService> services = Lists.newArrayList();
public ServiceManager()
{
registerService(new BanService());
registerService(new GameRuleService());
registerService(new UpdateCheckerService());
registerService(new AutoWipeService());
registerService(new CommandBlockerService());
}
public void startServices()
{
for (AbstractService service : services)
{
startService(service);
}
}
public void endServices()
{
services.forEach(this::endService);
}
public AbstractService getService(Class<? extends AbstractService> clazz)
{
return services.stream().filter(service -> service.getClass().isAssignableFrom(clazz)).findFirst().orElse(null);
}
public void startService(AbstractService service)
{
if (!service.isRepeating())
{
int time = service.repeatInSeconds();
BukkitTask task;
if (time == 0)
{
task = Bukkit.getScheduler().runTask(Plex.get(), service::run);
}
else
{
task = Bukkit.getScheduler().runTaskLater(Plex.get(), service::run, time);
}
service.setTaskId(task.getTaskId());
}
else if (service.isRepeating() && service.isAsynchronous())
{
BukkitTask task = Bukkit.getScheduler().runTaskTimerAsynchronously(Plex.get(), service::run, 0, 20L * service.repeatInSeconds());
service.setTaskId(task.getTaskId());
}
else if (service.isRepeating() && !service.isAsynchronous())
{
BukkitTask task = Bukkit.getScheduler().runTaskTimer(Plex.get(), service::run, 0, 20L * service.repeatInSeconds());
service.setTaskId(task.getTaskId());
}
if (!services.contains(service))
{
services.add(service);
}
service.onStart();
}
public void endService(AbstractService service, boolean remove)
{
Bukkit.getScheduler().cancelTask(service.getTaskId());
service.onEnd();
if (remove)
{
services.remove(service);
}
}
public void endService(AbstractService service)
{
endService(service, false);
}
private void registerService(AbstractService service)
{
services.add(service);
}
public int serviceCount()
{
return services.size();
}
}

44
src/main/java/dev/plex/services/impl/AutoWipeService.java
View File

@ -1,44 +0,0 @@
package dev.plex.services.impl;
import dev.plex.Plex;
import dev.plex.services.AbstractService;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import java.util.List;
public class AutoWipeService extends AbstractService
{
public AutoWipeService()
{
super(true, false);
}
@Override
public void run()
{
if (Plex.get().config.getBoolean("autowipe.enabled"))
{
List<String> entities = plugin.config.getStringList("autowipe.entities");
for (World world : Bukkit.getWorlds())
{
for (Entity entity : world.getEntities())
{
if (entities.stream().anyMatch(entityName -> entityName.equalsIgnoreCase(entity.getType().name())))
{
entity.remove();
}
}
}
}
}
@Override
public int repeatInSeconds()
{
return Math.max(1, plugin.config.getInt("autowipe.interval"));
}
}

38
src/main/java/dev/plex/services/impl/BanService.java
View File

@ -1,38 +0,0 @@
package dev.plex.services.impl;
import dev.plex.Plex;
import dev.plex.services.AbstractService;
import java.time.LocalDateTime;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
public class BanService extends AbstractService
{
public BanService()
{
super(true, true);
}
@Override
public void run()
{
Plex.get().getPunishmentManager().getActiveBans().whenComplete((punishments, throwable) ->
{
punishments.forEach(punishment ->
{
if (LocalDateTime.now().isAfter(punishment.getEndDate()))
{
Plex.get().getPunishmentManager().unban(punishment);
Bukkit.broadcast(Component.text("Plex - Unbanned " + Bukkit.getOfflinePlayer(punishment.getPunished()).getName()));
}
});
});
}
@Override
public int repeatInSeconds()
{
// Every 5 minutes
return 300;
}
}

25
src/main/java/dev/plex/services/impl/CommandBlockerService.java
View File

@ -1,25 +0,0 @@
package dev.plex.services.impl;
import dev.plex.services.AbstractService;
import dev.plex.util.PlexLog;
public class CommandBlockerService extends AbstractService
{
public CommandBlockerService()
{
super(false, true);
}
@Override
public void run()
{
plugin.getCommandBlockerManager().syncCommands();
PlexLog.log("Command Blocker commands loaded");
}
@Override
public int repeatInSeconds()
{
return 0;
}
}

41
src/main/java/dev/plex/services/impl/GameRuleService.java
View File

@ -1,41 +0,0 @@
package dev.plex.services.impl;
import dev.plex.services.AbstractService;
import dev.plex.util.PlexLog;
import dev.plex.util.PlexUtils;
import java.util.Locale;
import org.bukkit.Bukkit;
import org.bukkit.World;
public class GameRuleService extends AbstractService
{
public GameRuleService()
{
super(false, true);
}
@Override
public void run()
{
for (World world : Bukkit.getWorlds())
{
PlexUtils.commitGlobalGameRules(world);
PlexLog.log("Set global gamerules for world: " + world.getName());
}
for (String world : plugin.config.getConfigurationSection("worlds").getKeys(false))
{
World bukkitWorld = Bukkit.getWorld(world);
if (bukkitWorld != null)
{
PlexUtils.commitSpecificGameRules(bukkitWorld);
PlexLog.log("Set specific gamerules for world: " + world.toLowerCase(Locale.ROOT));
}
}
}
@Override
public int repeatInSeconds()
{
return 0;
}
}

33
src/main/java/dev/plex/services/impl/UpdateCheckerService.java
View File

@ -1,33 +0,0 @@
package dev.plex.services.impl;
import dev.plex.services.AbstractService;
import org.bukkit.Bukkit;
public class UpdateCheckerService extends AbstractService
{
private boolean newVersion = false;
public UpdateCheckerService()
{
super(true, true);
}
@Override
public void run()
{
if (!newVersion)
{
if (plugin.getUpdateChecker().getUpdateStatusMessage(Bukkit.getConsoleSender(), false, 1))
{
newVersion = true;
}
}
}
@Override
public int repeatInSeconds()
{
// Every 30 minutes
return 1800;
}
}