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

bazeling real hard today

Browse source
This commit is contained in:
kento2 2026-08-03 22:07:40 +02:00
parent 5cb75791e7
commit 80d9b07f0c
45 changed files with 426 additions and 718 deletions
Download patch file Download diff file Expand all files Collapse all files

17
core-bukkit-impl/BUILD Normal file
View file

@ -0,0 +1,17 @@
load("@rules_java//java:java_binary.bzl", "java_binary")
load("@rules_jvm_external//:defs.bzl", "artifact")
java_binary(
name = "core-bukkit-plugin",
srcs = glob(["src/main/**/*.java"]),
main_class = "none",
resources = glob(["src/main/resources/**"], allow_empty = True),
deps = [
"//core-bukkit-api:core-bukkit-api",
artifact("net.luckperms:api"),
artifact("io.papermc.paper:paper-api"),
artifact("io.nats:jnats"),
artifact("net.kyori:adventure-key:5.2.0"),
],
plugins = [ "//third_party:lombok_plugin" ],
)

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

@ -1,38 +0,0 @@
plugins {
id("java")
alias(libs.plugins.scrow.publish)
alias(libs.plugins.scrow.runserver)
alias(libs.plugins.shadow)
alias(libs.plugins.scrow.basedependencies)
alias(libs.plugins.scrow.database)
}
group = "de.kentoj.scrow"
dependencies {
implementation(project(":core-bukkit-api"))
compileOnly(libs.papermc.api)
implementation(libs.bson)
implementation(libs.nats)
implementation(libs.scrow.commandapi.bukkit) {
isChanging = true
}
implementation(libs.postgres)
compileOnly(libs.luckperms)
}
tasks.processResources {
filesMatching("plugin.yml") {
expand(
mapOf("version" to project.version.toString())
)
}
}
tasks.build {
dependsOn("shadowJar")
}
tasks.shadowJar {
archiveClassifier = ""
}

3
core-bukkit-impl/run/eula.txt
View file

@ -1,3 +0,0 @@
#By changing the setting below to TRUE you are indicating your agreement to our EULA (https://aka.ms/MinecraftEULA).
#Mon Jul 06 16:35:59 CEST 2026
eula=true

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

@ -26,12 +26,12 @@ public final class CoreImplPlugin extends JavaPlugin {
var cachedPrefixProvider = new CachedPrefixProvider();
ScrowAPISurface.initScrowAPI(this, cachedPrefixProvider);
ScrowAPI.getCommandApi().register(new CoinsCommand().getRootLiteral());
ScrowAPI.getCommandApi().register(FriendCommand.create());
ScrowAPI.getPlayerCommands().register(new CoinsCommand().getRootLiteral());
ScrowAPI.getPlayerCommands().register(FriendCommand.create());
var instanceCache = new InstanceCache();
ScrowAPI.getCommandApi().register(InstanceCommand.create(instanceCache));
ScrowAPI.getCommandApi().register(new PlayCommand().getRootLiteral());
ScrowAPI.getCommandApi().register(new LobbyCommand().getRootLiteral());
ScrowAPI.getCommands().register(InstanceCommand.create(instanceCache));
ScrowAPI.getPlayerCommands().register(new PlayCommand().getRootLiteral());
ScrowAPI.getPlayerCommands().register(new LobbyCommand().getRootLiteral());
var luckperms = LuckPermsProvider.get();
new LuckPermsPrefixSetter(luckperms, cachedPrefixProvider).init(this);

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

@ -22,6 +22,8 @@ import io.nats.client.Options;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.plugin.Plugin;
import org.jdbi.v3.core.Jdbi;
@ -67,7 +69,8 @@ public class ScrowAPISurface {
ScrowAPI.setPlayerFactory(playerId -> new NetworkPlayerImpl(ScrowAPI.getMessageBroker(), playerId));
ScrowAPI.setRegionManager(new RegionManagerImpl());
ScrowAPI.setCommandApi(new CommandAPI(plugin));
ScrowAPI.setCommands(new CommandAPI<>(plugin, CommandSender.class));
ScrowAPI.setPlayerCommands(new CommandAPI<>(plugin, Player.class));
ScrowAPI.setInstanceManager(new InstanceManagerImpl(ScrowAPI.getMessageBroker()));
ScrowAPI.setEconomyService(ScrowAPI.getJdbi() != null ?
new PostgresEconomyService(ScrowAPI.getJdbi()) : new InMemoryEconomyService());

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

@ -3,7 +3,6 @@ package de.kentoj.scrow.bukkit.command.economy;
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.literal.Literal;
import de.kentoj.kencommandapi.api.literal.RootLiteral;
import de.kentoj.kencommandapi.api.platform.MessageStyle;
@ -11,34 +10,27 @@ 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;
import java.util.concurrent.CompletableFuture;
public class CoinsCommand implements CommandExecutor<CommandSender> {
public final class CoinsCommand {
@Getter
private final RootLiteral<CommandSender> rootLiteral;
private final RootLiteral<Player> rootLiteral;
private final MessageStyle style;
public CoinsCommand() {
style = ScrowMessageStyle.GENERIC;
rootLiteral = Literal.rootLiteral(style, "coins", "bal", "balance");
rootLiteral.setPermission("command.coins.get.self");
rootLiteral.setExecutor(this);
var setLiteral = new CoinsSetLiteral(style).getLiteral();
setLiteral.setPermission("command.coins.set");
rootLiteral.addLiteral(setLiteral);
var getLiteral = new CoinsGetLiteral(style).getLiteral();
getLiteral.setPermission("command.coins.get.others");
rootLiteral.addLiteral(getLiteral);
rootLiteral = Literal.<Player>builder("coins", "bal", "balance")
.withPermission("command.coins.get.self")
.withExecutor(this::execute)
.withLiteral(new CoinsSetLiteral(style).getLiteral())
.withLiteral(new CoinsGetLiteral(style).getLiteral())
.asRootLiteral(style);
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
var player = ((Player) ctx.getSender());
public CompletableFuture<Result<Object, String>> execute(CommandContext<Player> ctx) {
var player = ctx.getSender();
return Tasks.supplyAsync(() ->
ScrowAPI.getEconomyService().getCoins(player.getUniqueId()))
.<Result<Object, String>>mapSync(amount -> {

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

@ -2,9 +2,8 @@ package de.kentoj.scrow.bukkit.command.economy;
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.CommandArgumentSpec;
import de.kentoj.kencommandapi.api.invocation.CommandContext;
import de.kentoj.kencommandapi.api.invocation.CommandExecutor;
import de.kentoj.kencommandapi.api.literal.Literal;
import de.kentoj.kencommandapi.api.platform.MessageStyle;
import de.kentoj.kencommandapi.type.OfflinePlayerArgumentType;
@ -13,30 +12,31 @@ import de.kentoj.scrow.bukkit.scheduler.Tasks;
import lombok.Getter;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.concurrent.CompletableFuture;
public class CoinsGetLiteral implements CommandExecutor<CommandSender> {
public final class CoinsGetLiteral {
@Getter
private final Literal<CommandSender> literal;
private final Literal<Player> literal;
private final MessageStyle style;
private final CommandArgument<CommandSender, OfflinePlayer> playerArg;
private final CommandArgumentSpec<Player, OfflinePlayer> playerArg;
public CoinsGetLiteral(MessageStyle style) {
this.style = style;
playerArg = CommandArgument.arg("player", OfflinePlayerArgumentType.getInstance());
playerArg.setDefaultValueProvider(sender -> (OfflinePlayer) sender);
literal = Literal.literal("get");
literal.addArgument(playerArg);
literal.setExecutor(this);
playerArg = CommandArgumentSpec.builder("player", new OfflinePlayerArgumentType<Player>())
.withDefaultValue(CommandContext::getSender)
.build();
literal = Literal.<Player>builder("get")
.withPermission("command.coins.get.others")
.withArgument(playerArg)
.withExecutor(this::execute)
.build();
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
private CompletableFuture<Result<Object, String>> execute(CommandContext<Player> ctx) {
var player = ctx.getArg(playerArg);
return Tasks.supplyAsync(() ->
ScrowAPI.getEconomyService().getCoins(player.getUniqueId()))
@ -45,5 +45,4 @@ public class CoinsGetLiteral implements CommandExecutor<CommandSender> {
return Results.success(new Object());
}).toFuture();
}
}

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

@ -2,11 +2,11 @@ package de.kentoj.scrow.bukkit.command.economy;
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.CommandArgumentSpec;
import de.kentoj.kencommandapi.api.argument.types.IntegerArgumentType;
import de.kentoj.kencommandapi.api.invocation.CommandContext;
import de.kentoj.kencommandapi.api.invocation.CommandExecutor;
import de.kentoj.kencommandapi.api.literal.Literal;
import de.kentoj.kencommandapi.api.literal.LiteralBuilder;
import de.kentoj.kencommandapi.api.platform.MessageStyle;
import de.kentoj.kencommandapi.type.OfflinePlayerArgumentType;
import de.kentoj.scrow.bukkit.ScrowAPI;
@ -14,32 +14,35 @@ import de.kentoj.scrow.bukkit.scheduler.Tasks;
import lombok.Getter;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.concurrent.CompletableFuture;
public class CoinsSetLiteral implements CommandExecutor<CommandSender> {
public final class CoinsSetLiteral {
@Getter
private final Literal<CommandSender> literal;
private final Literal<Player> literal;
private final MessageStyle style;
private final CommandArgument<CommandSender, OfflinePlayer> playerArg;
private final CommandArgument<CommandSender, Integer> amountArg;
private final CommandArgumentSpec<Player, OfflinePlayer> playerArg;
private final CommandArgumentSpec<Player, Integer> amountArg;
public CoinsSetLiteral(MessageStyle style) {
this.style = style;
playerArg = CommandArgument.arg("player", OfflinePlayerArgumentType.getInstance());
amountArg = CommandArgument.arg("amount", new IntegerArgumentType<>());
literal = Literal.literal("set");
literal.addArgument(playerArg);
literal.addArgument(amountArg);
literal.setExecutor(this);
playerArg = CommandArgumentSpec.builder("player", new OfflinePlayerArgumentType<Player>())
.withDefaultValue(CommandContext::getSender)
.build();
amountArg = CommandArgumentSpec.builder("amount", new IntegerArgumentType<Player>())
.build();
literal = Literal.<Player>builder("set")
.withPermission("command.coins.set")
.withArgument(playerArg)
.withArgument(amountArg)
.withExecutor(this::execute)
.build();
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
private CompletableFuture<Result<Object, String>> execute(CommandContext<Player> ctx) {
var player = ctx.getArg(playerArg);
var amount = ctx.getArg(amountArg);
return Tasks.runAsync(() ->

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

@ -2,24 +2,21 @@ package de.kentoj.scrow.bukkit.command.friends;
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.CommandArgumentSpec;
import de.kentoj.kencommandapi.api.invocation.CommandContext;
import de.kentoj.kencommandapi.api.invocation.CommandExecutor;
import de.kentoj.kencommandapi.api.literal.Literal;
import de.kentoj.kencommandapi.type.OfflinePlayerArgumentType;
import de.kentoj.scrow.bukkit.ScrowAPI;
import de.kentoj.scrow.bukkit.scheduler.Task;
import de.kentoj.scrow.bukkit.scheduler.Tasks;
import de.kentoj.scrowlib.convention.ScrowMessageStyle;
import de.kentoj.scrowlib.friends.FriendRequestService;
import de.kentoj.scrowlib.friends.FriendshipService;
import de.kentoj.scrowlib.friends.friendship.FriendshipImpl;
import de.kentoj.scrowlib.friends.request.FriendRequestImpl;
import de.kentoj.scrow.bukkit.scheduler.Task;
import de.kentoj.scrow.bukkit.scheduler.Tasks;
import de.kentoj.scrowlib.convention.ScrowMessageStyle;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import net.kyori.adventure.text.Component;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.time.Instant;
@ -27,27 +24,28 @@ import java.util.Objects;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
@RequiredArgsConstructor
public class FriendAddLiteral implements CommandExecutor<CommandSender> {
public class FriendAddLiteral {
@Getter
private final Literal<CommandSender> literal;
private final CommandArgument<CommandSender, OfflinePlayer> playerArg;
private final Literal<Player> literal;
private final CommandArgumentSpec<Player, OfflinePlayer> playerArg;
private final ScrowMessageStyle style;
private final FriendRequestService requestService = ScrowAPI.getFriendRequestService();
private final FriendshipService friendsService = ScrowAPI.getFriendshipService();
public FriendAddLiteral(ScrowMessageStyle style) {
this.style = style;
playerArg = CommandArgument.arg("player", OfflinePlayerArgumentType.getInstance());
literal = Literal.literal("add");
literal.addArgument(playerArg);
literal.setExecutor(this);
playerArg = CommandArgumentSpec.builder("player", new OfflinePlayerArgumentType<Player>())
.build();
literal = Literal.<Player>builder("add")
.withArgument(playerArg)
.withExecutor(this::execute)
.build();
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
var self = (Player) ctx.getSender();
private CompletableFuture<Result<Object, String>> execute(CommandContext<Player> ctx) {
var self = ctx.getSender();
var other = ctx.getArg(playerArg);
return Tasks.supplyAsync(() -> findAction(self, other)
.mapSuccess(action -> {

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

@ -9,19 +9,20 @@ import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.event.ClickEvent;
import net.kyori.adventure.text.event.HoverEvent;
import net.kyori.adventure.text.format.NamedTextColor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@NoArgsConstructor(access = AccessLevel.NONE)
public class FriendCommand {
public static RootLiteral<CommandSender> create() {
public static RootLiteral<Player> create() {
var style = new ScrowMessageStyle("Friends", NamedTextColor.AQUA);
RootLiteral<CommandSender> rootLiteral = Literal.rootLiteral(style, "f", "friend");
rootLiteral.addLiteral(new FriendListLiteral(style).getLiteral());
rootLiteral.addLiteral(new FriendAddLiteral(style).getLiteral());
rootLiteral.addLiteral(new FriendRemoveLiteral(style).getLiteral());
rootLiteral.addLiteral(new FriendRequestDeclineLiteral(style).getLiteral());
rootLiteral.addLiteral(new FriendRequestsLiteral(style).getLiteral());
return rootLiteral;
return Literal.<Player>builder("f", "friend")
.withLiteral(new FriendListLiteral(style).getLiteral())
.withLiteral(new FriendAddLiteral(style).getLiteral())
.withLiteral(new FriendRemoveLiteral(style).getLiteral())
.withLiteral(new FriendRequestDeclineLiteral(style).getLiteral())
.withLiteral(new FriendRequestsLiteral(style).getLiteral())
.asRootLiteral(style);
}
public static Component friendRequestOptions(String requestSenderName, boolean runInstantly) {

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

@ -3,18 +3,17 @@ package de.kentoj.scrow.bukkit.command.friends;
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.literal.Literal;
import de.kentoj.scrow.bukkit.ScrowAPI;
import de.kentoj.scrow.bukkit.scheduler.Tasks;
import de.kentoj.scrowlib.convention.ScrowMessageStyle;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.List;
@ -23,21 +22,17 @@ import java.util.concurrent.CompletableFuture;
import static java.util.Objects.requireNonNull;
import static net.kyori.adventure.text.Component.text;
public class FriendListLiteral implements CommandExecutor<CommandSender> {
@RequiredArgsConstructor
public final class FriendListLiteral {
@Getter
private final Literal<CommandSender> literal;
private final Literal<Player> literal = Literal.<Player>builder("list")
.withExecutor(this::displayFriendList)
.build();
private final ScrowMessageStyle style;
public FriendListLiteral(ScrowMessageStyle style) {
this.style = style;
this.literal = Literal.literal("list");
literal.setExecutor(this);
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
var sender = (Player) ctx.getSender();
private CompletableFuture<Result<Object, String>> displayFriendList(CommandContext<Player> ctx) {
var sender = ctx.getSender();
return Tasks.supplyAsync(() ->
ScrowAPI.getFriendshipService().getFriendships(sender.getUniqueId()))
.<Result<Object, String>>mapSync(friendships -> {

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

@ -2,9 +2,8 @@ package de.kentoj.scrow.bukkit.command.friends;
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.CommandArgumentSpec;
import de.kentoj.kencommandapi.api.invocation.CommandContext;
import de.kentoj.kencommandapi.api.invocation.CommandExecutor;
import de.kentoj.kencommandapi.api.literal.Literal;
import de.kentoj.kencommandapi.type.OfflinePlayerArgumentType;
import de.kentoj.scrow.bukkit.ScrowAPI;
@ -12,31 +11,31 @@ import de.kentoj.scrow.bukkit.scheduler.Tasks;
import de.kentoj.scrowlib.convention.ScrowMessageStyle;
import lombok.Getter;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.concurrent.CompletableFuture;
public class FriendRemoveLiteral implements CommandExecutor<CommandSender> {
public class FriendRemoveLiteral {
@Getter
private final Literal<CommandSender> literal;
private final CommandArgument<CommandSender, OfflinePlayer> playerArg;
private final Literal<Player> literal;
private final CommandArgumentSpec<Player, OfflinePlayer> playerArg;
private final ScrowMessageStyle style;
public FriendRemoveLiteral(ScrowMessageStyle style) {
FriendRemoveLiteral(ScrowMessageStyle style) {
this.style = style;
this.playerArg = CommandArgument.arg("player", OfflinePlayerArgumentType.getInstance());
this.literal = Literal.literal("remove");
this.literal.addArgument(playerArg);
this.literal.setExecutor(this);
playerArg = CommandArgumentSpec.<Player, OfflinePlayer>builder("player", new OfflinePlayerArgumentType<>())
.build();
literal = Literal.<Player>builder("remove")
.withArgument(playerArg)
.withExecutor(this::removeFriend)
.build();
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
private CompletableFuture<Result<Object, String>> removeFriend(CommandContext<Player> ctx) {
var friend = ctx.getArg(playerArg);
var player = (Player) ctx.getSender();
return Tasks.supplyAsync(() ->
ScrowAPI.getFriendshipService().deleteFriendship(friend.getUniqueId(), player.getUniqueId()))
ScrowAPI.getFriendshipService().deleteFriendship(friend.getUniqueId(), ctx.getSender().getUniqueId()))
.<Result<Object, String>>mapSync(deleted -> {
if (!deleted)
return Results.failure("You are not friends with " + friend.getName() + ".");

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

@ -2,43 +2,42 @@ package de.kentoj.scrow.bukkit.command.friends;
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.CommandArgumentSpec;
import de.kentoj.kencommandapi.api.invocation.CommandContext;
import de.kentoj.kencommandapi.api.invocation.CommandExecutor;
import de.kentoj.kencommandapi.api.literal.Literal;
import de.kentoj.kencommandapi.type.OfflinePlayerArgumentType;
import de.kentoj.scrow.bukkit.ScrowAPI;
import de.kentoj.scrowlib.friends.FriendRequestService;
import de.kentoj.scrow.bukkit.scheduler.Tasks;
import de.kentoj.scrowlib.convention.ScrowMessageStyle;
import de.kentoj.scrowlib.friends.FriendRequestService;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.concurrent.CompletableFuture;
@RequiredArgsConstructor
public class FriendRequestDeclineLiteral implements CommandExecutor<CommandSender> {
public class FriendRequestDeclineLiteral {
@Getter
private final Literal<CommandSender> literal;
private final CommandArgument<CommandSender, OfflinePlayer> playerArg;
private final Literal<Player> literal;
private final CommandArgumentSpec<Player, OfflinePlayer> playerArg;
private final ScrowMessageStyle style;
private final FriendRequestService requestService = ScrowAPI.getFriendRequestService();
public FriendRequestDeclineLiteral(ScrowMessageStyle style) {
FriendRequestDeclineLiteral(ScrowMessageStyle style) {
this.style = style;
playerArg = CommandArgument.arg("player", OfflinePlayerArgumentType.getInstance());
literal = Literal.literal("reject", "decline");
literal.addArgument(playerArg);
literal.setExecutor(this);
playerArg = CommandArgumentSpec.builder("player", new OfflinePlayerArgumentType<Player>())
.build();
literal = Literal.<Player>builder("reject", "decline")
.withArgument(playerArg)
.withExecutor(this::declineFriendRequest)
.build();
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
var self = (Player) ctx.getSender();
private CompletableFuture<Result<Object, String>> declineFriendRequest(CommandContext<Player> ctx) {
var self = ctx.getSender();
var other = ctx.getArg(playerArg);
return Tasks.supplyAsync(() ->
requestService.deleteFriendRequest(other.getUniqueId(), self.getUniqueId()))

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

@ -3,18 +3,18 @@ package de.kentoj.scrow.bukkit.command.friends;
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.literal.Literal;
import de.kentoj.scrow.bukkit.ScrowAPI;
import de.kentoj.scrowlib.friends.FriendRequest;
import de.kentoj.scrow.bukkit.scheduler.Tasks;
import de.kentoj.scrowlib.convention.ScrowMessageStyle;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.List;
@ -22,28 +22,23 @@ import java.util.concurrent.CompletableFuture;
import static net.kyori.adventure.text.Component.text;
public class FriendRequestsLiteral implements CommandExecutor<CommandSender> {
@RequiredArgsConstructor(access = AccessLevel.PACKAGE)
public class FriendRequestsLiteral {
@Getter
private final Literal<CommandSender> literal;
private final Literal<Player> literal = Literal.<Player>builder("requests")
.withExecutor(this::displayFriendRequests)
.build();
private final ScrowMessageStyle style;
public FriendRequestsLiteral(ScrowMessageStyle style) {
this.style = style;
literal = Literal.literal("requests");
literal.setExecutor(this);
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
var sender = (Player) ctx.getSender();
private CompletableFuture<Result<Object, String>> displayFriendRequests(CommandContext<Player> ctx) {
return Tasks.supplyAsync(() ->
ScrowAPI.getFriendRequestService().getFriendRequestsTo(sender.getUniqueId()))
ScrowAPI.getFriendRequestService().getFriendRequestsTo(ctx.getSender().getUniqueId()))
.<Result<Object, String>>mapAsync(list -> {
if (list.isEmpty()) return Results.failure("You have no friend requests.");
var requesters = list.stream().sorted(this::compareByAge).map(fr -> Bukkit.getOfflinePlayer(fr.getFrom()).getName());
sender.sendMessage(formatList(requesters.toList()));
ctx.getSender().sendMessage(formatList(requesters.toList()));
return Results.success(new Object());
}).toFuture();
}

10
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/command/instance/InstanceCommand.java
View file

@ -12,10 +12,10 @@ import org.bukkit.command.CommandSender;
public class InstanceCommand {
public static RootLiteral<CommandSender> create(InstanceCache instanceCache) {
var style = new ScrowMessageStyle("server-manager", NamedTextColor.RED);
RootLiteral<CommandSender> rootLiteral = Literal.rootLiteral(style, "instance", "server-manager");
rootLiteral.addLiteral(new InstanceListLiteral(style).getNode());
rootLiteral.addLiteral(new InstanceDeployLiteral(style).getLiteral());
rootLiteral.addLiteral(new InstanceDestroyLiteral(instanceCache, style).getLiteral());
return rootLiteral;
return Literal.<CommandSender>builder("instance", "server-manager")
.withLiteral(new InstanceListLiteral(style).getLiteral())
.withLiteral(new InstanceDeployLiteral(style).getLiteral())
.withLiteral(new InstanceDestroyLiteral(instanceCache, style).getLiteral())
.asRootLiteral(style);
}
}

23
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/command/instance/InstanceDeployLiteral.java
View file

@ -2,10 +2,9 @@ package de.kentoj.scrow.bukkit.command.instance;
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.CommandArgumentSpec;
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.literal.Literal;
import de.kentoj.scrow.bukkit.ScrowAPI;
import de.kentoj.scrow.bukkit.scheduler.Tasks;
@ -15,25 +14,25 @@ import org.bukkit.command.CommandSender;
import java.util.concurrent.CompletableFuture;
public class InstanceDeployLiteral implements CommandExecutor<CommandSender> {
public class InstanceDeployLiteral {
@Getter
private final Literal<CommandSender> literal;
private final CommandArgument<CommandSender, String> templateArg;
private final CommandArgumentSpec<CommandSender, String> templateArg;
private final ScrowMessageStyle style;
public InstanceDeployLiteral(ScrowMessageStyle style) {
InstanceDeployLiteral(ScrowMessageStyle style) {
this.style = style;
templateArg = CommandArgument.arg("template", new StringArgumentType<>());
literal = Literal.literal("deploy");
literal.addArgument(templateArg);
literal.setExecutor(this);
templateArg = CommandArgumentSpec.builder("template", new StringArgumentType<CommandSender>())
.build();
literal = Literal.<CommandSender>builder("deploy")
.withArgument(templateArg)
.withExecutor(this::deployInstance)
.build();
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
private CompletableFuture<Result<Object, String>> deployInstance(CommandContext<CommandSender> ctx) {
var template = ctx.getArg(templateArg);
ctx.getSender().sendMessage(style.ok("Deploying instance... this may take a while."));
return Tasks.supplyAsync(() ->

29
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/command/instance/InstanceDestroyLiteral.java
View file

@ -2,10 +2,9 @@ package de.kentoj.scrow.bukkit.command.instance;
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.CommandArgumentSpec;
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.literal.Literal;
import de.kentoj.scrow.bukkit.ScrowAPI;
import de.kentoj.scrow.bukkit.scheduler.Tasks;
@ -16,27 +15,29 @@ import org.bukkit.command.CommandSender;
import java.util.concurrent.CompletableFuture;
public class InstanceDestroyLiteral implements CommandExecutor<CommandSender> {
public class InstanceDestroyLiteral {
@Getter
private final Literal<CommandSender> literal;
private final CommandArgument<CommandSender, String> handleArg;
private final CommandArgumentSpec<CommandSender, String> handleArg;
private final ScrowMessageStyle style;
public InstanceDestroyLiteral(InstanceCache cache, ScrowMessageStyle style) {
InstanceDestroyLiteral(InstanceCache cache, ScrowMessageStyle style) {
this.style = style;
handleArg = CommandArgument.arg("handle", new StringArgumentType<>());
handleArg.setSuggestionProvider(ctx -> cache.getInstances().stream()
.map(ServerInstance::getHandle)
.toList());
literal = Literal.literal("destroy");
literal.addArgument(handleArg);
literal.setExecutor(this);
handleArg = CommandArgumentSpec.builder("handle", new StringArgumentType<CommandSender>())
.withSuggestionProvider(_ ->
cache.getInstances().stream()
.map(ServerInstance::getHandle)
.toList())
.build();
literal = Literal.<CommandSender>builder("destroy")
.withArgument(handleArg)
.withExecutor(this::destroyInstance)
.build();
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
private CompletableFuture<Result<Object, String>> destroyInstance(CommandContext<CommandSender> ctx) {
var handle = ctx.getArg(handleArg);
return Tasks.supplyAsync(() -> ScrowAPI.getInstanceManager().destroyInstance(handle))
.<Result<Object, String>>mapSync(found -> {

15
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/command/instance/InstanceListLiteral.java
View file

@ -3,7 +3,6 @@ package de.kentoj.scrow.bukkit.command.instance;
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.literal.Literal;
import de.kentoj.scrow.bukkit.ScrowAPI;
import de.kentoj.scrow.bukkit.scheduler.Tasks;
@ -14,20 +13,20 @@ import org.bukkit.command.CommandSender;
import java.util.concurrent.CompletableFuture;
public class InstanceListLiteral implements CommandExecutor<CommandSender> {
public class InstanceListLiteral {
@Getter
private final Literal<CommandSender> node;
private final Literal<CommandSender> literal;
private final ScrowMessageStyle style;
public InstanceListLiteral(ScrowMessageStyle style) {
InstanceListLiteral(ScrowMessageStyle style) {
this.style = style;
this.node = Literal.literal("list");
this.node.setExecutor(this);
this.literal = Literal.<CommandSender>builder("list")
.withExecutor(this::displayInstanceList)
.build();
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
private CompletableFuture<Result<Object, String>> displayInstanceList(CommandContext<CommandSender> ctx) {
return Tasks.supplyAsync(() ->
ScrowAPI.getInstanceManager().getInstances())
.<Result<Object, String>>mapSync(instances -> {

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

@ -3,26 +3,22 @@ package de.kentoj.scrow.bukkit.command.instance;
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.SyncCommandExecutor;
import de.kentoj.kencommandapi.api.literal.Literal;
import de.kentoj.kencommandapi.api.literal.RootLiteral;
import de.kentoj.kencommandapi.api.platform.MessageStyle;
import de.kentoj.scrowlib.convention.ScrowMessageStyle;
import lombok.Getter;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
public class LobbyCommand implements SyncCommandExecutor<CommandSender> {
public class LobbyCommand {
@Getter
private final RootLiteral<CommandSender> rootLiteral;
private final RootLiteral<Player> rootLiteral = Literal.<Player>builder("lobby", "l", "hub")
.withSyncExecutor(this::sendToLobby)
.asRootLiteral(ScrowMessageStyle.GENERIC);
public LobbyCommand() {
this.rootLiteral = Literal.rootLiteral(MessageStyle.PLAIN, "lobby", "l", "hub");
this.rootLiteral.setExecutor(this);
}
@Override
public Result<Object, String> executeSync(CommandContext<CommandSender> ctx) {
private Result<Object, String> sendToLobby(CommandContext<Player> ctx) {
Bukkit.dispatchCommand(ctx.getSender(), "play lobby");
return Results.success(new Object());
}

25
core-bukkit-impl/src/main/java/de/kentoj/scrow/bukkit/command/instance/PlayCommand.java
View file

@ -2,7 +2,7 @@ package de.kentoj.scrow.bukkit.command.instance;
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.CommandArgumentSpec;
import de.kentoj.kencommandapi.api.argument.types.StringArgumentType;
import de.kentoj.kencommandapi.api.invocation.CommandContext;
import de.kentoj.kencommandapi.api.invocation.CommandExecutor;
@ -17,26 +17,23 @@ import org.bukkit.entity.Player;
import java.util.concurrent.CompletableFuture;
public class PlayCommand implements CommandExecutor<CommandSender> {
public class PlayCommand {
@Getter
private final RootLiteral<CommandSender> rootLiteral;
private final CommandArgument<CommandSender, String> gamemodeArg;
private final RootLiteral<Player> rootLiteral;
private final CommandArgumentSpec<Player, String> gamemodeArg;
public PlayCommand() {
var style = ScrowMessageStyle.GENERIC;
gamemodeArg = CommandArgument.arg("gamemode", new StringArgumentType<>());
rootLiteral = Literal.rootLiteral(style, "play", "queue");
rootLiteral.addArgument(this.gamemodeArg);
rootLiteral.setExecutor(this);
gamemodeArg = CommandArgumentSpec.builder("gamemode", new StringArgumentType<Player>()).build();
rootLiteral = Literal.<Player>builder("play", "queue")
.withArgument(gamemodeArg)
.withExecutor(this::execute)
.asRootLiteral(style);
}
@Override
public CompletableFuture<Result<Object, String>> execute(CommandContext<CommandSender> ctx) {
private CompletableFuture<Result<Object, String>> execute(CommandContext<Player> ctx) {
var gamemode = ctx.getArg(gamemodeArg);
var player = (Player) ctx.getSender();
return Tasks.supplyAsync(() -> ScrowAPI.getInstanceManager().getInstances())
.mapAsync(instances -> {
var instance = instances.stream()
@ -47,7 +44,7 @@ public class PlayCommand implements CommandExecutor<CommandSender> {
return Results.failure("No instance for " + gamemode + " found.");
return Results.ofCallable(() -> {
ScrowAPI.getPlayer(player).sendToInstance(instance.getHandle());
ScrowAPI.getPlayer(ctx.getSender()).sendToInstance(instance.getHandle());
return new Object();
}).mapFailure(Exception::getMessage);
}).toFuture();

1
core-bukkit-impl/src/main/resources/plugin.yml
View file

@ -1,5 +1,6 @@
name: "CoreBukkit"
version: "${version}"
depend: [ "LuckPerms" ]
main: "de.kentoj.scrow.bukkit.CoreImplPlugin"
api-version: "1.21"
author: "Kento2"