scrow/scrow-monorepo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 2 Wiki Activity Actions

currently refactoring a lot

Browse source
This commit is contained in:
kento2 2026-07-04 19:01:18 +02:00
parent 700b5d5d10
commit 31eb8a92eb
42 changed files with 454 additions and 433 deletions
Download patch file Download diff file Expand all files Collapse all files

3
core-bukkit-impl/build.gradle.kts
View file

@ -5,7 +5,6 @@ plugins {
id("de.kentoj.scrow.scrow-repository")
id("de.kentoj.scrow.base-dependencies")
id("de.kentoj.scrow.database")
id("de.kentoj.scrow.reactor")
}
group = "de.kentoj.scrow"
@ -22,7 +21,7 @@ dependencies {
implementation(project(":core-bukkit-api"))
// http://forge.kentoj.de/scrow/-/packages/maven/de.kentoj.scrow:kencommandapi-core
implementation("de.kentoj.scrow:kencommandapi-core:0.22")
implementation("de.kentoj.scrow:kencommandapi-core:0.23")
}
tasks {

7
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/CoreImplPlugin.java
View file

@ -1,9 +1,8 @@
package de.kentoj.scrow.bukkit;
import de.kentoj.scrow.bukkit.crown.CrownCommand;
import de.kentoj.scrow.bukkit.economy.command.CoinsCommand;
import de.kentoj.scrow.bukkit.economy.command.CoinsSetLiteral;
import de.kentoj.scrow.bukkit.friends.command.FriendCommand;
import de.kentoj.scrow.bukkit.instancemanager.command.InstanceCommand;
import de.kentoj.scrow.bukkit.region.RegionPlayerTracker;
import de.kentoj.scrow.bukkit.region.RegionTask;
import de.kentoj.scrow.bukkit.server.LobbyCommand;
@ -27,8 +26,8 @@ public class CoreImplPlugin extends JavaPlugin {
{
ScrowAPI.getCommandApi().register(new CoinsCommand().getRootNode());
ScrowAPI.getCommandApi().register(new FriendCommand().getRootNode());
ScrowAPI.getCommandApi().register(new CrownCommand().getRootNode());
ScrowAPI.getCommandApi().register(FriendCommand.create());
ScrowAPI.getCommandApi().register(InstanceCommand.create());
ScrowAPI.getCommandApi().register(new PlayCommand().getRootNode());
ScrowAPI.getCommandApi().register(new LobbyCommand().getRootNode());
}

22
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/ScrowAPISurface.java
View file

@ -8,18 +8,14 @@ import de.kentoj.scrow.bukkit.friends.friendship.PostgresFriendshipService;
import de.kentoj.scrow.bukkit.friends.request.InMemoryFriendRequestService;
import de.kentoj.scrow.bukkit.friends.request.PostgresFriendRequestService;
import de.kentoj.scrow.bukkit.region.RegionManagerImpl;
import de.kentoj.scrowlib.connection.DatabaseConnectionFactoryImpl;
import de.kentoj.scrowlib.servermanager.InstanceManagerImpl;
import de.kentoj.scrowlib.instancemanager.InstanceManagerImpl;
import de.kentoj.scrowlib.utils.EnvUtils;
import io.nats.client.Nats;
import io.nats.client.Options;
import io.r2dbc.spi.ConnectionFactories;
import io.r2dbc.spi.ConnectionFactory;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.bukkit.Bukkit;
import org.bukkit.plugin.Plugin;
import reactor.core.scheduler.Schedulers;
import org.jdbi.v3.core.Jdbi;
import java.io.IOException;
@ -41,26 +37,20 @@ public class ScrowAPISurface {
}
if (enableDatabase) {
ConnectionFactory factory = ConnectionFactories.get(EnvUtils.envOrThrow("HOST_POSTGRES"));
ScrowAPI.setJdbi(new DatabaseConnectionFactoryImpl(factory));
ScrowAPI.setJdbi(Jdbi.create(EnvUtils.envOrThrow("HOST_POSTGRES")));
}
ScrowAPI.setRegionManager(new RegionManagerImpl());
ScrowAPI.setCommandApi(new CommandAPI(plugin));
ScrowAPI.setInstanceManager(new InstanceManagerImpl(ScrowAPI.getNats()));
ScrowAPI.setEconomyService(ScrowAPI.getJdbi() != null ?
new PostgresEconomyService(ScrowAPI.getJdbi()) : new InMemoryEconomyService());
new PostgresEconomyService() : new InMemoryEconomyService());
ScrowAPI.setFriendRequestService(ScrowAPI.getJdbi() != null ?
new PostgresFriendRequestService(ScrowAPI.getJdbi()) : new InMemoryFriendRequestService());
new PostgresFriendRequestService() : new InMemoryFriendRequestService());
ScrowAPI.setFriendshipService(ScrowAPI.getJdbi() != null ?
new PostgresFriendshipService(ScrowAPI.getJdbi()) : new InMemoryFriendshipService());
new PostgresFriendshipService() : new InMemoryFriendshipService());
}
public static void destroyScrowAPI() {
try {
ScrowAPI.getJdbi().close();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}

23
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/crown/CrownCommand.java
View file

@ -1,23 +0,0 @@
package de.kentoj.scrow.bukkit.crown;
import de.kentoj.kencommandapi.api.node.CommandNode;
import de.kentoj.scrowlib.convention.ScrowMessageStyle;
import lombok.Getter;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import org.bukkit.command.CommandSender;
public class CrownCommand {
@Getter
private final CommandNode<CommandSender> rootNode;
public CrownCommand() {
this.rootNode = CommandNode.node("crown", "server-manager");
var style = new ScrowMessageStyle(Component.text("crown")
.color(NamedTextColor.GOLD));
this.rootNode.addLiteral(new CrownListServersLiteral(style).getNode());
this.rootNode.addLiteral(new CrownDeployServerLiteral(style).getRootNode());
this.rootNode.addLiteral(new CrownDestroyServerLiteral(style).getRootNode());
}
}

40
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/crown/CrownDeployServerLiteral.java
View file

@ -1,40 +0,0 @@
package de.kentoj.scrow.bukkit.crown;
import de.kentoj.kencommandapi.api.node.CommandNode;
import de.kentoj.kencommandapi.api.argument.CommandArgument;
import de.kentoj.kencommandapi.api.argument.types.StringArgumentType;
import de.kentoj.kencommandapi.api.invocation.CommandContext;
import de.kentoj.kencommandapi.api.invocation.CommandExecutor;
import com.leakyabstractions.result.api.Result;
import de.kentoj.scrow.bukkit.ScrowAPI;
import lombok.Getter;
import org.bukkit.command.CommandSender;
import java.util.concurrent.CompletableFuture;
public class CrownDeployServerLiteral implements CommandExecutor<CommandSender> {
@Getter
private final CommandNode<CommandSender> rootNode;
private final CommandArgument<CommandSender, String> templateArg;
public CrownDeployServerLiteral() {
this.rootNode = CommandNode.node("deploy-server");
this.rootNode.setExecutor(this);
{
this.templateArg = CommandArgument.arg("template", new StringArgumentType<>());
this.rootNode.addArgument(templateArg);
}
}
@Override
public CompletableFuture<Result<Object,String>> execute(CommandContext<CommandSender> ctx) {
var template = ctx.getArg(templateArg);
return ScrowAPI.getInstanceManager().deployInstance(template)
.map(server -> {
ctx.getSender().sendMessage("Deployed instance of " + template + " with handle " + server.getHandle());
// FIXME handle unknown server
return Result.success();
}).toFuture();
}
}

49
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/crown/CrownDestroyServerLiteral.java
View file

@ -1,49 +0,0 @@
package de.kentoj.scrow.bukkit.crown;
import de.kentoj.kencommandapi.api.node.CommandNode;
import de.kentoj.kencommandapi.api.argument.CommandArgument;
import de.kentoj.kencommandapi.api.argument.types.StringArgumentType;
import de.kentoj.kencommandapi.api.invocation.CommandContext;
import de.kentoj.kencommandapi.api.invocation.CommandExecutor;
import com.leakyabstractions.result.api.Result;
import com.leakyabstractions.result.api.Results;
import de.kentoj.scrow.bukkit.ScrowAPI;
import de.kentoj.scrowlib.servermanager.ServerInstance;
import lombok.Getter;
import org.bukkit.command.CommandSender;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
public class CrownDestroyServerLiteral implements CommandExecutor<CommandSender> {
@Getter
private final CommandNode<CommandSender> rootNode;
private final CommandArgument<CommandSender, String> handleArg;
public CrownDestroyServerLiteral() {
this.rootNode = CommandNode.node("destroy-server");
this.rootNode.setExecutor(this);
{
this.handleArg = CommandArgument.arg("template", new StringArgumentType<>());
this.handleArg.setSuggestionProvider(ctx -> {
//noinspection CodeBlock2Expr
return ScrowAPI.getInstanceManager().getInstances()
.map(ServerInstance::getHandle)
.collect(Collectors.toSet())
.toFuture();
});
this.rootNode.addArgument(handleArg);
}
}
@Override
public CompletableFuture<Result<Object,String>> execute(CommandContext<CommandSender> ctx) {
var handle = ctx.getArg(handleArg);
return ScrowAPI.getInstanceManager().destroyInstance(handle)
.map(__ -> {
ctx.getSender().sendMessage("Destroyed server with handle " + handle);
return Result.success();
}).toFuture();
}
}

41
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/crown/CrownListServersLiteral.java
View file

@ -1,41 +0,0 @@
package de.kentoj.scrow.bukkit.crown;
import de.kentoj.kencommandapi.api.invocation.CommandContext;
import de.kentoj.kencommandapi.api.invocation.CommandExecutor;
import com.leakyabstractions.result.api.Result;
import de.kentoj.kencommandapi.api.node.CommandNode;
import de.kentoj.scrow.bukkit.ScrowAPI;
import de.kentoj.scrowlib.convention.ScrowMessageStyle;
import lombok.Getter;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import java.util.concurrent.CompletableFuture;
public class CrownListServersLiteral implements CommandExecutor<CommandSender> {
@Getter
private final CommandNode<CommandSender> node;
private final ScrowMessageStyle style;
public CrownListServersLiteral(ScrowMessageStyle style) {
this.style = style;
this.node = CommandNode.node("list-servers");
this.node.setExecutor(this);
}
@Override
public CompletableFuture<Result<Object,String>> execute(CommandContext<CommandSender> ctx) {
return ScrowAPI.getInstanceManager().getInstances()
.collectList()
.map(list -> style.list(Component.text("Running instances:"),
list.stream()
.map(inst ->
Component.text(inst.getHandle() + " on port " + inst.getPort() + ": " + inst.getState())
)
.toList())
)
.doOnNext(ctx.getSender()::sendMessage)
.thenReturn(Result.success()).toFuture();
}
}

4
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/economy/command/CoinsCommand.java
View file

@ -26,7 +26,7 @@ public class CoinsCommand implements CommandExecutor<CommandSender> {
private final MessageStyle style;
public CoinsCommand() {
style = new ScrowMessageStyle("Coins", NamedTextColor.GOLD);
style = ScrowMessageStyle.GENERIC;
rootNode = CommandNode.rootNode(style, "coins", "bal", "balance");
rootNode.setPermission("command.coins.get.self");
@ -44,7 +44,7 @@ public class CoinsCommand implements CommandExecutor<CommandSender> {
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
var player = ((Player) ctx.getSender());
return Tasks.supplyAsync(() ->
ScrowAPI.getEconomyService().getCoins(player.getUniqueId()))
ScrowAPI.getEconomyService().getCoins(player.getUniqueId()))
.<Result<Object, String>>mapSync(amount -> {
player.sendMessage(style.ok("You have " + amount + "$"));
return Results.success(new Object());

1
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/friends/command/FriendCommand.java
View file

@ -17,5 +17,6 @@ public class FriendCommand {
rootNode.addLiteral(new FriendAddLiteral(style).getLiteral());
rootNode.addLiteral(new FriendRemoveLiteral(style).getRootNode());
rootNode.addLiteral(new FriendRequestsLiteral(style).getLiteral());
return rootNode;
}
}

21
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/instancemanager/command/InstanceCommand.java Normal file
View file

@ -0,0 +1,21 @@
package de.kentoj.scrow.bukkit.instancemanager.command;
import de.kentoj.kencommandapi.api.node.CommandNode;
import de.kentoj.kencommandapi.api.node.RootCommandNode;
import de.kentoj.scrowlib.convention.ScrowMessageStyle;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import net.kyori.adventure.text.format.NamedTextColor;
import org.bukkit.command.CommandSender;
@NoArgsConstructor(access = AccessLevel.NONE)
public class InstanceCommand {
public static RootCommandNode<CommandSender> create() {
var style = new ScrowMessageStyle("server-manager", NamedTextColor.RED);
RootCommandNode<CommandSender> rootNode = CommandNode.rootNode(style, "instance", "server-manager");
rootNode.addLiteral(new InstanceListLiteral(style).getNode());
rootNode.addLiteral(new InstanceDeployLiteral(style).getLiteral());
rootNode.addLiteral(new InstanceDestroyLiteral(style).getLiteral());
return rootNode;
}
}

47
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/instancemanager/command/InstanceDeployLiteral.java Normal file
View file

@ -0,0 +1,47 @@
package de.kentoj.scrow.bukkit.instancemanager.command;
import com.leakyabstractions.result.api.Result;
import com.leakyabstractions.result.core.Results;
import de.kentoj.kencommandapi.api.argument.CommandArgument;
import de.kentoj.kencommandapi.api.argument.types.StringArgumentType;
import de.kentoj.kencommandapi.api.invocation.CommandContext;
import de.kentoj.kencommandapi.api.invocation.CommandExecutor;
import de.kentoj.kencommandapi.api.node.CommandNode;
import de.kentoj.scrow.bukkit.ScrowAPI;
import de.kentoj.scrow.bukkit.scheduler.Tasks;
import de.kentoj.scrowlib.convention.ScrowMessageStyle;
import lombok.Getter;
import org.bukkit.command.CommandSender;
import java.util.concurrent.CompletableFuture;
public class InstanceDeployLiteral implements CommandExecutor<CommandSender> {
@Getter
private final CommandNode<CommandSender> literal;
private final CommandArgument<CommandSender, String> templateArg;
private final ScrowMessageStyle style;
public InstanceDeployLiteral(ScrowMessageStyle style) {
this.style = style;
templateArg = CommandArgument.arg("template", new StringArgumentType<>());
literal = CommandNode.node("deploy");
literal.addArgument(templateArg);
literal.setExecutor(this);
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
var template = ctx.getArg(templateArg);
ctx.getSender().sendMessage(style.ok("Deploying instance... this may take a while"));
return Tasks.supplyAsync(() ->
ScrowAPI.getInstanceManager().deployInstance(template))
.<Result<Object, String>>mapSync(instance -> {
ctx.getSender().sendMessage(style.ok("Deployed instance of " + template + " with handle " + instance.getHandle()));
// FIXME handle unknown server
return Results.success(new Object());
}).toFuture();
}
}

52
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/instancemanager/command/InstanceDestroyLiteral.java Normal file
View file

@ -0,0 +1,52 @@
package de.kentoj.scrow.bukkit.instancemanager.command;
import com.leakyabstractions.result.api.Result;
import com.leakyabstractions.result.core.Results;
import de.kentoj.kencommandapi.api.argument.CommandArgument;
import de.kentoj.kencommandapi.api.argument.types.StringArgumentType;
import de.kentoj.kencommandapi.api.invocation.CommandContext;
import de.kentoj.kencommandapi.api.invocation.CommandExecutor;
import de.kentoj.kencommandapi.api.node.CommandNode;
import de.kentoj.scrow.bukkit.ScrowAPI;
import de.kentoj.scrow.bukkit.scheduler.Tasks;
import de.kentoj.scrowlib.convention.ScrowMessageStyle;
import de.kentoj.scrowlib.instancemanager.ServerInstance;
import lombok.Getter;
import org.bukkit.command.CommandSender;
import java.util.concurrent.CompletableFuture;
public class InstanceDestroyLiteral implements CommandExecutor<CommandSender> {
@Getter
private final CommandNode<CommandSender> literal;
private final CommandArgument<CommandSender, String> handleArg;
private final ScrowMessageStyle style;
public InstanceDestroyLiteral(ScrowMessageStyle style) {
this.style = style;
handleArg = CommandArgument.arg("handle", new StringArgumentType<>());
handleArg.setSuggestionProvider(ctx ->
Tasks.supplyAsync(() -> ScrowAPI.getInstanceManager().getInstances().stream()
.map(ServerInstance::getHandle)
.toList())
.toFuture());
literal = CommandNode.node("destroy");
literal.addArgument(handleArg);
literal.setExecutor(this);
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
var handle = ctx.getArg(handleArg);
return Tasks.supplyAsync(() -> ScrowAPI.getInstanceManager().destroyInstance(handle))
.<Result<Object, String>>mapSync(found -> {
if (!found)
return Results.failure("No instance with that handle found");
ctx.getSender().sendMessage(style.ok("Destroyed server with handle " + handle));
return Results.success(new Object());
}).toFuture();
}
}

43
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/instancemanager/command/InstanceListLiteral.java Normal file
View file

@ -0,0 +1,43 @@
package de.kentoj.scrow.bukkit.instancemanager.command;
import com.leakyabstractions.result.api.Result;
import com.leakyabstractions.result.core.Results;
import de.kentoj.kencommandapi.api.invocation.CommandContext;
import de.kentoj.kencommandapi.api.invocation.CommandExecutor;
import de.kentoj.kencommandapi.api.node.CommandNode;
import de.kentoj.scrow.bukkit.ScrowAPI;
import de.kentoj.scrow.bukkit.scheduler.Tasks;
import de.kentoj.scrowlib.convention.ScrowMessageStyle;
import lombok.Getter;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import java.util.concurrent.CompletableFuture;
public class InstanceListLiteral implements CommandExecutor<CommandSender> {
@Getter
private final CommandNode<CommandSender> node;
private final ScrowMessageStyle style;
public InstanceListLiteral(ScrowMessageStyle style) {
this.style = style;
this.node = CommandNode.node("list");
this.node.setExecutor(this);
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
return Tasks.supplyAsync(() ->
ScrowAPI.getInstanceManager().getInstances())
.<Result<Object, String>>mapSync(instances -> {
var msg = Component.text("Running instances:");
for (var inst : instances) {
msg = msg.appendNewline()
.append(Component.text(" - " + inst.getHandle() + " on port " + inst.getPort()));
}
ctx.getSender().sendMessage(style.ok(msg));
return Results.success(new Object());
}).toFuture();
}
}

12
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/playermanager/PlayerManagerImpl.java
View file

@ -1,8 +1,8 @@
package de.kentoj.scrow.bukkit.playermanager;
import com.leakyabstractions.result.api.Result;
import de.kentoj.scrow.bukkit.misc.PlayerManager;
import de.kentoj.scrowlib.messaging.MessageBroker;
import de.kentoj.scrowlib.utils.ResultUtils;
import lombok.RequiredArgsConstructor;
import org.bson.Document;
@ -14,10 +14,10 @@ public class PlayerManagerImpl implements PlayerManager {
private final MessageBroker messageBroker;
@Override
public Result<Object, String> sendPlayer(UUID playerId, String instanceHandle) {
return messageBroker.request("players.send", new Document()
.append("playerId", playerId)
.append("handle", instanceHandle))
.mapSuccess(__ -> null);
public void sendPlayer(UUID playerId, String instanceHandle) {
var result = messageBroker.request("players.send", new Document()
.append("playerId", playerId)
.append("handle", instanceHandle));
ResultUtils.unwrap(result, "failed to send player to " + instanceHandle);
}
}

18
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/server/LobbyCommand.java
View file

@ -2,28 +2,28 @@ package de.kentoj.scrow.bukkit.server;
import com.leakyabstractions.result.api.Result;
import com.leakyabstractions.result.core.Results;
import de.kentoj.kencommandapi.api.node.CommandNode;
import de.kentoj.kencommandapi.api.invocation.CommandContext;
import de.kentoj.kencommandapi.api.invocation.CommandExecutor;
import de.kentoj.kencommandapi.api.invocation.SyncCommandExecutor;
import de.kentoj.kencommandapi.api.node.CommandNode;
import de.kentoj.kencommandapi.api.node.RootCommandNode;
import de.kentoj.kencommandapi.api.platform.MessageStyle;
import lombok.Getter;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import java.util.concurrent.CompletableFuture;
public class LobbyCommand implements CommandExecutor<CommandSender> {
public class LobbyCommand implements SyncCommandExecutor<CommandSender> {
@Getter
private final CommandNode<CommandSender> rootNode;
private final RootCommandNode<CommandSender> rootNode;
public LobbyCommand() {
this.rootNode = CommandNode.node("lobby", "l", "hub");
this.rootNode = CommandNode.rootNode(MessageStyle.PLAIN, "lobby", "l", "hub");
this.rootNode.setExecutor(this);
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
public Result<Object, String> executeSync(CommandContext<CommandSender> ctx) {
Bukkit.dispatchCommand(ctx.getSender(), "play lobby");
return CompletableFuture.completedFuture(Results.success(new Object()));
return Results.success(new Object());
}
}

30
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/server/PlayCommand.java
View file

@ -7,8 +7,10 @@ import de.kentoj.kencommandapi.api.argument.types.StringArgumentType;
import de.kentoj.kencommandapi.api.invocation.CommandContext;
import de.kentoj.kencommandapi.api.invocation.CommandExecutor;
import de.kentoj.kencommandapi.api.node.CommandNode;
import de.kentoj.kencommandapi.api.node.RootCommandNode;
import de.kentoj.scrow.bukkit.ScrowAPI;
import de.kentoj.scrow.bukkit.scheduler.Tasks;
import de.kentoj.scrowlib.convention.ScrowMessageStyle;
import lombok.Getter;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@ -18,28 +20,36 @@ import java.util.concurrent.CompletableFuture;
public class PlayCommand implements CommandExecutor<CommandSender> {
@Getter
private final CommandNode<CommandSender> rootNode;
private final RootCommandNode<CommandSender> rootNode;
private final CommandArgument<CommandSender, String> gamemodeArg;
public PlayCommand() {
this.rootNode = CommandNode.node("play", "queue");
this.gamemodeArg = CommandArgument.arg("gamemode", new StringArgumentType<>());
this.rootNode.addArgument(this.gamemodeArg);
this.rootNode.setExecutor(this);
var style = ScrowMessageStyle.GENERIC;
gamemodeArg = CommandArgument.arg("gamemode", new StringArgumentType<>());
rootNode = CommandNode.rootNode(style, "play", "queue");
rootNode.addArgument(this.gamemodeArg);
rootNode.setExecutor(this);
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
var gamemode = ctx.getArg(gamemodeArg);
var player = (Player) ctx.getSender();
return Tasks.supplyAsync(() -> ScrowAPI.getInstanceManager().getInstances()
.mapSuccess(instances -> {
return Tasks.supplyAsync(() -> ScrowAPI.getInstanceManager().getInstances())
.mapAsync(instances -> {
var instance = instances.stream()
.filter(inst -> inst.getTemplate().equals(gamemode))
.findFirst()
.orElse(null);
if (instance == null) return Results.failure("No instance available");
return ScrowAPI.getPlayerManager().sendPlayer(player.getUniqueId(), instance.getHandle());
}));
if (instance == null)
return Results.failure("No instance for " + gamemode + " found");
return Results.ofCallable(() -> {
ScrowAPI.getPlayerManager().sendPlayer(player.getUniqueId(), instance.getHandle());
return new Object();
}).mapFailure(Exception::getMessage);
}).toFuture();
}
}