Altitude/Essentia
5
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: Altitude:ff2824f287adf97260e02cf1cdc68c243a017e40
Branches Tags
Altitude:main
Altitude:dev/update
Altitude:dev/storage
..
compare: Altitude:4dba5f3c41566dd11c5061fb23f564cd88a5f7a7
Branches Tags
Altitude:dev/update
Altitude:dev/storage
Altitude:main

9 Commits
ff2824f287 ... 4dba5f3c41

Author SHA1 Message Date
Len 4dba5f3c41 Add RepairCommand 2024-10-04 21:05:26 +02:00
Len dbb3f45898 Move command permissions to EssentiaCommand interface. 2024-10-04 18:34:02 +02:00
Len 162ffd3599 Update GameModeCommand to use native GameModeArgument 2024-10-04 17:04:34 +02:00
Len 430e6fb898 Fix typo in EnchantmentArgument.java 2024-10-04 17:04:34 +02:00
Len aede22811a Add TimeCommand 2024-08-15 21:08:08 +02:00
Len a8221a68af Add reset option to pweather 2024-08-15 17:49:45 +02:00
Len 29559b83c4 Add SetSpawnCommand.java 2024-08-15 17:43:31 +02:00
Len be8b7e20df Add PlayerWeatherCommand.java and WeatherArgument.java 2024-08-15 17:23:12 +02:00
Len 6a8e21852c Add WeatherCommand.java 2024-08-15 17:15:31 +02:00
44 changed files with 798 additions and 136 deletions
Show Stats Expand all files Collapse all files

2
plugin/src/main/java/com/alttd/essentia/EssentiaPlugin.java
View File

@ -58,7 +58,7 @@ public class EssentiaPlugin extends JavaPlugin implements EssentiaAPI {
}
void loadCommands() {
Reflections reflections = new Reflections("com.alttd.essentia.commands");
Reflections reflections = new Reflections("com.alttd.essentia.commands.list");
Set<Class<?>> subTypes = reflections.get(Scanners.SubTypes.of(EssentiaCommand.class).asClass());
LifecycleEventManager<Plugin> manager = this.getLifecycleManager();

18
plugin/src/main/java/com/alttd/essentia/commands/EssentiaCommand.java
View File

@ -9,6 +9,8 @@ import java.util.List;
// TODO -- add optional -s -silent parameters to commands?
public interface EssentiaCommand {
String commandName();
@NotNull LiteralCommandNode<CommandSourceStack> command();
default String description() {
@ -19,4 +21,20 @@ public interface EssentiaCommand {
return Collections.emptyList();
}
default String baseCommandPermission() {
return "essentia.command.player." + commandName();
}
default String baseOtherCommandPermission() {
return "essentia.command.player." + commandName() + "other";
}
default String adminCommandPermission() {
return "essentia.command.admin." + commandName();
}
default String adminOtherCommandPermission() {
return "essentia.command.admin." + commandName() + "other";
}
}

11
plugin/src/main/java/com/alttd/essentia/commands/admin/BurnCommand.java
View File

@ -16,14 +16,17 @@ import org.jetbrains.annotations.NotNull;
public class BurnCommand implements EssentiaCommand {
static String commandName = "burn";
@Override
public String commandName() {
return "burn";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
)
.executes((source) -> {
if (source.getSource().getSender() instanceof Player player)
@ -33,7 +36,7 @@ public class BurnCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

11
plugin/src/main/java/com/alttd/essentia/commands/admin/ClearInventoryCommand.java
View File

@ -16,14 +16,17 @@ import org.jetbrains.annotations.NotNull;
public class ClearInventoryCommand implements EssentiaCommand {
static String commandName = "clearinventory";
@Override
public String commandName() {
return "clearinventory";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.executes((source) -> {
@ -34,7 +37,7 @@ public class ClearInventoryCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

11
plugin/src/main/java/com/alttd/essentia/commands/admin/CuffCommand.java
View File

@ -19,18 +19,21 @@ import org.jetbrains.annotations.NotNull;
public class CuffCommand implements EssentiaCommand {
static String commandName = "cuff";
@Override
public String commandName() {
return "cuff";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
)
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

11
plugin/src/main/java/com/alttd/essentia/commands/admin/EnchantCommand.java
View File

@ -20,14 +20,17 @@ import org.jetbrains.annotations.NotNull;
public class EnchantCommand implements EssentiaCommand {
static String commandName = "enchant";
@Override
public String commandName() {
return "enchant";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
)
.then(
Commands.argument("enchantment", new EnchantmentArgument())
@ -51,7 +54,7 @@ public class EnchantCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

9
plugin/src/main/java/com/alttd/essentia/commands/admin/EssentiaAdminCommand.java
View File

@ -10,11 +10,16 @@ import org.jetbrains.annotations.NotNull;
public class EssentiaAdminCommand implements EssentiaCommand {
@Override
public String commandName() {
return "essentiareload";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal("essentia")
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin.reload"))
Commands.literal(commandName())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()))
.executes((commandContext -> 1))
.then(
Commands.literal("reload")

11
plugin/src/main/java/com/alttd/essentia/commands/admin/FeedCommand.java
View File

@ -16,14 +16,17 @@ import org.jetbrains.annotations.NotNull;
public class FeedCommand implements EssentiaCommand {
static String commandName = "feed";
@Override
public String commandName() {
return "feed";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.executes((source) -> {
@ -34,7 +37,7 @@ public class FeedCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

11
plugin/src/main/java/com/alttd/essentia/commands/admin/FlyCommand.java
View File

@ -20,14 +20,17 @@ import org.jetbrains.annotations.NotNull;
public class FlyCommand implements EssentiaCommand {
static String commandName = "fly";
@Override
public String commandName() {
return "fly";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.executes((source) -> {
@ -38,7 +41,7 @@ public class FlyCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

11
plugin/src/main/java/com/alttd/essentia/commands/admin/FlySpeedCommand.java
View File

@ -18,14 +18,17 @@ import org.jetbrains.annotations.NotNull;
public class FlySpeedCommand implements EssentiaCommand {
static String commandName = "flyspeed";
@Override
public String commandName() {
return "flyspeed";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
).then(
Commands.argument("speed", FloatArgumentType.floatArg(-1, 1))
.executes((source) -> {
@ -39,7 +42,7 @@ public class FlySpeedCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

14
plugin/src/main/java/com/alttd/essentia/commands/admin/GameModeCommand.java
View File

@ -1,7 +1,6 @@
package com.alttd.essentia.commands.admin;
import com.alttd.essentia.commands.EssentiaCommand;
import com.alttd.essentia.commands.argumement.GameModeArgument;
import com.alttd.essentia.configuration.Config;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import com.mojang.brigadier.tree.LiteralCommandNode;
@ -18,17 +17,20 @@ import org.jetbrains.annotations.NotNull;
public class GameModeCommand implements EssentiaCommand {
static String commandName = "gamemode";
@Override
public String commandName() {
return "gamemode";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
)
.then(
Commands.argument("gamemode", new GameModeArgument())
Commands.argument("gamemode", ArgumentTypes.gameMode())
.executes((source) -> {
if (!(source.getSource().getSender() instanceof Player player))
return 1;
@ -39,7 +41,7 @@ public class GameModeCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

11
plugin/src/main/java/com/alttd/essentia/commands/admin/GodCommand.java
View File

@ -20,14 +20,17 @@ import org.jetbrains.annotations.NotNull;
public class GodCommand implements EssentiaCommand {
static String commandName = "god";
@Override
public String commandName() {
return "god";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.executes((source) -> {
@ -38,7 +41,7 @@ public class GodCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

14
plugin/src/main/java/com/alttd/essentia/commands/admin/HealCommand.java
View File

@ -14,17 +14,19 @@ import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
public class HealCommand
implements EssentiaCommand {
public class HealCommand implements EssentiaCommand {
static String commandName = "heal";
@Override
public String commandName() {
return "heal";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.executes((source) -> {
@ -35,7 +37,7 @@ public class HealCommand
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

11
plugin/src/main/java/com/alttd/essentia/commands/admin/InfoCommand.java
View File

@ -15,14 +15,17 @@ import org.jetbrains.annotations.NotNull;
public class InfoCommand implements EssentiaCommand {
static String commandName = "info";
@Override
public String commandName() {
return "info";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
)
.executes((source) -> {
if (source.getSource().getSender() instanceof Player player)
@ -32,7 +35,7 @@ public class InfoCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

97
plugin/src/main/java/com/alttd/essentia/commands/admin/PlayerTimeCommand.java Normal file
View File

@ -0,0 +1,97 @@
package com.alttd.essentia.commands.admin;
import com.alttd.essentia.commands.EssentiaCommand;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import com.mojang.brigadier.tree.LiteralCommandNode;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import io.papermc.paper.command.brigadier.Commands;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import java.util.List;
// TODO -- output messages
public class PlayerTimeCommand implements EssentiaCommand {
@Override
public String commandName() {
return "playertime";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.then(
Commands.literal("freeze")
.executes(commandContext -> {
if (commandContext.getSource().getSender() instanceof Player player)
setTime(player, player.getPlayerTime());
return 1;
})
)
.then(
Commands.literal("unfreeze")
.executes(commandContext -> {
if (commandContext.getSource().getSender() instanceof Player player)
reset(player);
return 1;
})
)
.then(
Commands.literal("day")
.executes(commandContext -> {
if (commandContext.getSource().getSender() instanceof Player player)
setTime(player, 1000);
return 1;
})
)
.then(
Commands.literal("noon")
.executes(commandContext -> {
if (commandContext.getSource().getSender() instanceof Player player)
setTime(player, 6000);
return 1;
})
)
.then(
Commands.literal("night")
.executes(commandContext -> {
if (commandContext.getSource().getSender() instanceof Player player)
setTime(player, 13000);
return 1;
})
)
.then(
Commands.literal("midnight")
.executes(commandContext -> {
if (commandContext.getSource().getSender() instanceof Player player)
setTime(player, 18000);
return 1;
})
);
return builder.build();
}
void reset(Player player) {
player.resetPlayerTime();
}
void setTime(Player player, long time) {
player.setPlayerTime(time, false);
}
public List<String> aliases() {
return List.of("ptime");
}
}

80
plugin/src/main/java/com/alttd/essentia/commands/admin/PlayerWeatherCommand.java Normal file
View File

@ -0,0 +1,80 @@
package com.alttd.essentia.commands.admin;
import com.alttd.essentia.commands.EssentiaCommand;
import com.alttd.essentia.commands.argumement.WeatherArgument;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import com.mojang.brigadier.tree.LiteralCommandNode;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import io.papermc.paper.command.brigadier.Commands;
import io.papermc.paper.command.brigadier.argument.ArgumentTypes;
import io.papermc.paper.command.brigadier.argument.resolvers.selector.PlayerSelectorArgumentResolver;
import org.bukkit.WeatherType;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import java.util.List;
// TODO -- output messages
public class PlayerWeatherCommand implements EssentiaCommand {
@Override
public String commandName() {
return "playerweather";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.then(
Commands.literal("reset")
.executes(commandContext -> {
if (commandContext.getSource().getSender() instanceof Player player)
resetWeather(player);
return 1;
})
)
.then(
Commands.argument("weather", new WeatherArgument())
.executes(commandContext -> {
if (!(commandContext.getSource().getSender() instanceof Player player))
return 1;
WeatherType weatherType = commandContext.getArgument("weather", WeatherType.class);
execute(commandContext.getSource().getSender(), player, weatherType);
return 1;
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes(commandContext -> {
CommandSourceStack sourceStack = commandContext.getSource();
Player target = commandContext.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();
WeatherType weatherType = commandContext.getArgument("weather", WeatherType.class);
execute(commandContext.getSource().getSender(), target, weatherType);
return 1;
})
)
);
return builder.build();
}
public void execute(CommandSender sender, Player target, WeatherType weatherType) {
target.setPlayerWeather(weatherType);
}
void resetWeather(Player player) {
player.resetPlayerWeather();
}
public List<String> aliases() {
return List.of("pweather");
}
}

79
plugin/src/main/java/com/alttd/essentia/commands/admin/RepairCommand.java Normal file
View File

@ -0,0 +1,79 @@
package com.alttd.essentia.commands.admin;
import com.alttd.essentia.commands.EssentiaCommand;
import com.alttd.essentia.commands.argumement.EquipmentArgumentType;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import com.mojang.brigadier.tree.LiteralCommandNode;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import io.papermc.paper.command.brigadier.Commands;
import io.papermc.paper.command.brigadier.argument.ArgumentTypes;
import io.papermc.paper.command.brigadier.argument.resolvers.selector.PlayerSelectorArgumentResolver;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.inventory.EquipmentSlot;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.Damageable;
import org.jetbrains.annotations.NotNull;
public class RepairCommand implements EssentiaCommand {
@Override
public String commandName() {
return "repair";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()))
// .executes((source) -> {
// if (source.getSource().getSender() instanceof Player player)
// execute(player, player);
//
// return 1;
// })
.then(Commands.argument("equipmentslot", new EquipmentArgumentType())
.executes((source) -> {
if (!(source.getSource().getSender() instanceof Player player))
return 1;
EquipmentSlot equipmentSlot = source.getArgument("equipmentslot", EquipmentSlot.class);
execute(source.getSource().getSender(), player, equipmentSlot);
return 1;
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();
EquipmentSlot equipmentSlot = source.getArgument("equipmentslot", EquipmentSlot.class);
execute(source.getSource().getSender(), target, equipmentSlot);
return 1;
})
)
);
return builder.build();
}
// TODO - placeholders and messages from config
public void execute(CommandSender sender, Player target, EquipmentSlot equipmentSlot) {
TagResolver placeholders = TagResolver.resolver(
Placeholder.component("requester", sender.name()),
Placeholder.component("target", target.displayName())
);
ItemStack itemStack = target.getInventory().getItem(equipmentSlot);
if (!(itemStack.getItemMeta() instanceof Damageable damageable))
return; // send message can not repair this item
damageable.setDamage(0);
sender.sendRichMessage(target == sender ? "You have repaired your <item>." : "<sender> has repaired your <item>.", placeholders);
if (target != sender)
target.sendRichMessage("You repaired <target>'s <item>.", placeholders);
}
}

48
plugin/src/main/java/com/alttd/essentia/commands/admin/SetSpawnCommand.java Normal file
View File

@ -0,0 +1,48 @@
package com.alttd.essentia.commands.admin;
import com.alttd.essentia.commands.EssentiaCommand;
import com.alttd.essentia.configuration.Config;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import com.mojang.brigadier.tree.LiteralCommandNode;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import io.papermc.paper.command.brigadier.Commands;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
public class SetSpawnCommand implements EssentiaCommand {
@Override
public String commandName() {
return "setspawn";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.executes((source) -> {
if (source.getSource().getSender() instanceof Player player)
execute(player, player);
return 1;
});
return builder.build();
}
public void execute(CommandSender sender, Player target) {
// Todo - output messages
World world = target.getWorld();
world.setSpawnLocation(target.getLocation());
// TODO -- method in config to update & save
Config.config.set("spawn-world", world.getName());
Config.SPAWN_WORLD = world.getName();
Config.saveConfig();
}
}

11
plugin/src/main/java/com/alttd/essentia/commands/admin/SmiteCommand.java
View File

@ -18,14 +18,17 @@ import java.util.List;
public class SmiteCommand implements EssentiaCommand {
static String commandName = "smite";
@Override
public String commandName() {
return "smite";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
)
.executes((source) -> {
if (source.getSource().getSender() instanceof Player player)
@ -35,7 +38,7 @@ public class SmiteCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

11
plugin/src/main/java/com/alttd/essentia/commands/admin/TeleportCommand.java
View File

@ -14,19 +14,22 @@ import java.util.List;
public class TeleportCommand implements EssentiaCommand {
static String commandName = "teleport";
@Override
public String commandName() {
return "teleport";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

11
plugin/src/main/java/com/alttd/essentia/commands/admin/TeleportHereCommand.java
View File

@ -14,19 +14,22 @@ import java.util.List;
public class TeleportHereCommand implements EssentiaCommand {
static String commandName = "teleporthere";
@Override
public String commandName() {
return "teleporthere";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

11
plugin/src/main/java/com/alttd/essentia/commands/admin/TeleportPositionCommand.java
View File

@ -16,14 +16,17 @@ import java.util.List;
public class TeleportPositionCommand implements EssentiaCommand {
static String commandName = "teleportposition";
@Override
public String commandName() {
return "teleportposition";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.then(
@ -39,7 +42,7 @@ public class TeleportPositionCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
if (!(source.getSource().getSender() instanceof Player player))
return 1;

93
plugin/src/main/java/com/alttd/essentia/commands/admin/TimeCommand.java Normal file
View File

@ -0,0 +1,93 @@
package com.alttd.essentia.commands.admin;
import com.alttd.essentia.commands.EssentiaCommand;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import com.mojang.brigadier.tree.LiteralCommandNode;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import io.papermc.paper.command.brigadier.Commands;
import org.bukkit.GameRule;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
// TODO -- output messages
public class TimeCommand implements EssentiaCommand {
@Override
public String commandName() {
return "time";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.then(
Commands.literal("freeze")
.executes(commandContext -> {
if (commandContext.getSource().getSender() instanceof Player player)
freeze(player, true);
return 1;
})
)
.then(
Commands.literal("unfreeze")
.executes(commandContext -> {
if (commandContext.getSource().getSender() instanceof Player player)
freeze(player, false);
return 1;
})
)
.then(
Commands.literal("day")
.executes(commandContext -> {
if (commandContext.getSource().getSender() instanceof Player player)
setTime(player, 1000);
return 1;
})
)
.then(
Commands.literal("noon")
.executes(commandContext -> {
if (commandContext.getSource().getSender() instanceof Player player)
setTime(player, 6000);
return 1;
})
)
.then(
Commands.literal("night")
.executes(commandContext -> {
if (commandContext.getSource().getSender() instanceof Player player)
setTime(player, 13000);
return 1;
})
)
.then(
Commands.literal("midnight")
.executes(commandContext -> {
if (commandContext.getSource().getSender() instanceof Player player)
setTime(player, 18000);
return 1;
})
);
return builder.build();
}
void freeze(Player player, boolean value) {
player.getWorld().setGameRule(GameRule.DO_DAYLIGHT_CYCLE, value);
}
void setTime(Player player, int time) {
player.getWorld().setTime(time);
}
}

11
plugin/src/main/java/com/alttd/essentia/commands/admin/UnCuffCommand.java
View File

@ -19,18 +19,21 @@ import org.jetbrains.annotations.NotNull;
public class UnCuffCommand implements EssentiaCommand {
static String commandName = "uncuff";
@Override
public String commandName() {
return "uncuff";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
)
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

11
plugin/src/main/java/com/alttd/essentia/commands/admin/WalkSpeedCommand.java
View File

@ -18,14 +18,17 @@ import org.jetbrains.annotations.NotNull;
public class WalkSpeedCommand implements EssentiaCommand {
static String commandName = "walkspeed";
@Override
public String commandName() {
return "walkspeed";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
).then(
Commands.argument("speed", FloatArgumentType.floatArg(-1, 1))
.executes((source) -> {
@ -39,7 +42,7 @@ public class WalkSpeedCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

103
plugin/src/main/java/com/alttd/essentia/commands/admin/WeatherCommand.java Normal file
View File

@ -0,0 +1,103 @@
package com.alttd.essentia.commands.admin;
import com.alttd.essentia.commands.EssentiaCommand;
import com.mojang.brigadier.arguments.IntegerArgumentType;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import com.mojang.brigadier.tree.LiteralCommandNode;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import io.papermc.paper.command.brigadier.Commands;
import io.papermc.paper.command.brigadier.argument.ArgumentTypes;
import io.papermc.paper.command.brigadier.argument.resolvers.selector.PlayerSelectorArgumentResolver;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import java.util.Random;
// TODO -- output messages
public class WeatherCommand implements EssentiaCommand {
@Override
public String commandName() {
return "weather";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.then(
Commands.literal("clear")
.executes(commandContext -> {
if (commandContext.getSource().getSender() instanceof Player player)
clearWeather(player, -1);
return 1;
})
.then(
Commands.argument("duration", ArgumentTypes.time())
.executes(commandContext -> {
int duration = commandContext.getArgument("duration", Integer.class);
if (commandContext.getSource().getSender() instanceof Player player)
clearWeather(player, duration);
return 1;
})
)
)
.then(
Commands.literal("rain")
.executes(commandContext -> {
if (commandContext.getSource().getSender() instanceof Player player)
setRain(player, -1, false);
return 1;
})
.then(
Commands.argument("duration", ArgumentTypes.time())
.executes(commandContext -> {
int duration = commandContext.getArgument("duration", Integer.class);
if (commandContext.getSource().getSender() instanceof Player player)
setRain(player, duration, false);
return 1;
})
)
)
.then(
Commands.literal("thunder")
.executes(commandContext -> {
if (commandContext.getSource().getSender() instanceof Player player)
setRain(player, -1, true);
return 1;
})
.then(
Commands.argument("duration", ArgumentTypes.time())
.executes(commandContext -> {
int duration = commandContext.getArgument("duration", Integer.class);
if (commandContext.getSource().getSender() instanceof Player player)
setRain(player, duration, true);
return 1;
})
)
);
return builder.build();
}
public void clearWeather(Player player, int duration) {
player.getWorld().setClearWeatherDuration(duration == -1 ? new Random().nextInt() : duration);
}
public void setRain(Player player, int duration, boolean thunder) {
player.getWorld().setStorm(thunder);
player.getWorld().setWeatherDuration(duration == -1 ? new Random().nextInt() : duration);
}
}

11
plugin/src/main/java/com/alttd/essentia/commands/admin/WorkBenchCommand.java
View File

@ -17,14 +17,17 @@ import java.util.List;
public class WorkBenchCommand implements EssentiaCommand {
static String commandName = "workbench";
@Override
public String commandName() {
return "workbench";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
)
.executes((source) -> {
if (source.getSource().getSender() instanceof Player player)
@ -34,7 +37,7 @@ public class WorkBenchCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

2
plugin/src/main/java/com/alttd/essentia/commands/argumement/EnchantmentArgument.java
View File

@ -27,7 +27,7 @@ public class EnchantmentArgument implements CustomArgumentType.Converted<Enchant
try {
return Enchantment.getByKey(NamespacedKey.minecraft(nativeType));
} catch (Exception e) {
Message message = MessageComponentSerializer.message().serialize(Component.text("Invalid gamemode %s!".formatted(nativeType), NamedTextColor.RED));
Message message = MessageComponentSerializer.message().serialize(Component.text("Invalid enchantment %s!".formatted(nativeType), NamedTextColor.RED));
throw new CommandSyntaxException(new SimpleCommandExceptionType(message), message);
}

49
plugin/src/main/java/com/alttd/essentia/commands/argumement/EquipmentArgumentType.java Normal file
View File

@ -0,0 +1,49 @@
package com.alttd.essentia.commands.argumement;
import com.mojang.brigadier.Message;
import com.mojang.brigadier.arguments.ArgumentType;
import com.mojang.brigadier.arguments.StringArgumentType;
import com.mojang.brigadier.context.CommandContext;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import com.mojang.brigadier.exceptions.SimpleCommandExceptionType;
import com.mojang.brigadier.suggestion.Suggestions;
import com.mojang.brigadier.suggestion.SuggestionsBuilder;
import io.papermc.paper.command.brigadier.MessageComponentSerializer;
import io.papermc.paper.command.brigadier.argument.CustomArgumentType;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import org.bukkit.inventory.EquipmentSlot;
import org.jetbrains.annotations.NotNull;
import java.util.concurrent.CompletableFuture;
public class EquipmentArgumentType implements CustomArgumentType.Converted<EquipmentSlot, String> {
@Override
public @NotNull EquipmentSlot convert(String nativeType) throws CommandSyntaxException {
try {
return EquipmentSlot.valueOf(nativeType.toUpperCase());
} catch (Exception e) {
Message message = MessageComponentSerializer.message().serialize(Component.text("Invalid EquipmentSlot %s!".formatted(nativeType), NamedTextColor.RED));
throw new CommandSyntaxException(new SimpleCommandExceptionType(message), message);
}
}
@Override
public @NotNull ArgumentType<String> getNativeType() {
return StringArgumentType.word();
}
@Override
public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
for (EquipmentSlot equipmentSlot : EquipmentSlot.values()) {
builder.suggest(equipmentSlot.name().toLowerCase());
}
return CompletableFuture.completedFuture(
builder.build()
);
}
}

14
plugin/src/main/java/com/alttd/essentia/commands/argumement/GameModeArgument.java → plugin/src/main/java/com/alttd/essentia/commands/argumement/WeatherArgument.java
View File

@ -12,19 +12,19 @@ import io.papermc.paper.command.brigadier.MessageComponentSerializer;
import io.papermc.paper.command.brigadier.argument.CustomArgumentType;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import org.bukkit.GameMode;
import org.bukkit.WeatherType;
import org.jetbrains.annotations.NotNull;
import java.util.concurrent.CompletableFuture;
public class GameModeArgument implements CustomArgumentType.Converted<GameMode, String> {
public class WeatherArgument implements CustomArgumentType.Converted<WeatherType, String> {
@Override
public @NotNull GameMode convert(String nativeType) throws CommandSyntaxException {
public @NotNull WeatherType convert(String nativeType) throws CommandSyntaxException {
try {
return GameMode.valueOf(nativeType.toUpperCase());
return WeatherType.valueOf(nativeType.toUpperCase());
} catch (Exception e) {
Message message = MessageComponentSerializer.message().serialize(Component.text("Invalid gamemode %s!".formatted(nativeType), NamedTextColor.RED));
Message message = MessageComponentSerializer.message().serialize(Component.text("Invalid WeatherType %s!".formatted(nativeType), NamedTextColor.RED));
throw new CommandSyntaxException(new SimpleCommandExceptionType(message), message);
}
@ -37,8 +37,8 @@ public class GameModeArgument implements CustomArgumentType.Converted<GameMode,
@Override
public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
for (GameMode gameMode : GameMode.values()) {
builder.suggest(gameMode.name().toLowerCase());
for (WeatherType weatherType : WeatherType.values()) {
builder.suggest(weatherType.name().toLowerCase());
}
return CompletableFuture.completedFuture(

9
plugin/src/main/java/com/alttd/essentia/commands/player/BackCommand.java
View File

@ -18,14 +18,17 @@ import org.jetbrains.annotations.NotNull;
public class BackCommand implements EssentiaCommand {
static String commandName = "back";
@Override
public String commandName() {
return "back";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.executes((source) -> {

9
plugin/src/main/java/com/alttd/essentia/commands/player/DeathBackCommand.java
View File

@ -20,14 +20,17 @@ import java.util.List;
public class DeathBackCommand implements EssentiaCommand {
static String commandName = "deathback";
@Override
public String commandName() {
return "deathback";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.executes((source) -> {

11
plugin/src/main/java/com/alttd/essentia/commands/player/DelHomeCommand.java
View File

@ -23,14 +23,17 @@ import java.util.Collection;
public class DelHomeCommand implements EssentiaCommand {
static String commandName = "delhome";
@Override
public String commandName() {
return "delhome";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.executes((source) -> {
@ -70,7 +73,7 @@ public class DelHomeCommand implements EssentiaCommand {
)
.then(
Commands.argument("player", new OfflinePlayerArgument())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(baseOtherCommandPermission()))
.then(
Commands.argument("home", StringArgumentType.word())
.suggests((context, suggestionsBuilder) -> {

11
plugin/src/main/java/com/alttd/essentia/commands/player/DisposeCommand.java
View File

@ -18,14 +18,17 @@ import org.jetbrains.annotations.NotNull;
public class DisposeCommand implements EssentiaCommand {
static String commandName = "dispose";
@Override
public String commandName() {
return "dispose";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName)
commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission())
)
.executes((source) -> {
if (source.getSource().getSender() instanceof Player player)
@ -35,7 +38,7 @@ public class DisposeCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(baseOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

9
plugin/src/main/java/com/alttd/essentia/commands/player/HomeCommand.java
View File

@ -26,14 +26,17 @@ import java.util.Collection;
// TODO - home other
public class HomeCommand implements EssentiaCommand {
static String commandName = "home";
@Override
public String commandName() {
return "home";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.executes((source) -> {

11
plugin/src/main/java/com/alttd/essentia/commands/player/HomeListCommand.java
View File

@ -19,14 +19,17 @@ import java.util.List;
public class HomeListCommand implements EssentiaCommand {
static String commandName = "homelist";
@Override
public String commandName() {
return "homelist";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName)
commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission())
)
.executes((source) -> {
if (source.getSource().getSender() instanceof Player player)
@ -36,7 +39,7 @@ public class HomeListCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", new OfflinePlayerCompletingArgument())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(baseOtherCommandPermission()))
.executes((source) -> {
OfflinePlayer target = source.getArgument("player", OfflinePlayer.class);
execute(source.getSource().getSender(), target);

11
plugin/src/main/java/com/alttd/essentia/commands/player/SetHomeCommand.java
View File

@ -20,14 +20,17 @@ import org.jetbrains.annotations.NotNull;
public class SetHomeCommand implements EssentiaCommand {
static String commandName = "sethome";
@Override
public String commandName() {
return "sethome";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.executes((source) -> {
@ -49,7 +52,7 @@ public class SetHomeCommand implements EssentiaCommand {
)
.then(
Commands.argument("player", new OfflinePlayerArgument())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(baseOtherCommandPermission()))
.then(
Commands.argument("name", StringArgumentType.word())
.executes((source) -> {

11
plugin/src/main/java/com/alttd/essentia/commands/player/SpawnCommand.java
View File

@ -21,14 +21,17 @@ import org.jetbrains.annotations.NotNull;
public class SpawnCommand implements EssentiaCommand {
static String commandName = "spawn";
@Override
public String commandName() {
return "spawn";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName)
commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission())
)
.executes((source) -> {
if (source.getSource().getSender() instanceof Player player)
@ -38,7 +41,7 @@ public class SpawnCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(baseOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

9
plugin/src/main/java/com/alttd/essentia/commands/player/TeleportAcceptCommand.java
View File

@ -16,14 +16,17 @@ import java.util.List;
public class TeleportAcceptCommand implements EssentiaCommand {
static String commandName = "teleportaccept";
@Override
public String commandName() {
return "teleportaccept";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.executes((source) -> {

9
plugin/src/main/java/com/alttd/essentia/commands/player/TeleportDenyCommand.java
View File

@ -16,14 +16,17 @@ import java.util.List;
public class TeleportDenyCommand implements EssentiaCommand {
static String commandName = "teleportdeny";
@Override
public String commandName() {
return "teleportdeny";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.executes((source) -> {

11
plugin/src/main/java/com/alttd/essentia/commands/player/TeleportRequestCommand.java
View File

@ -20,19 +20,22 @@ import java.util.List;
public class TeleportRequestCommand implements EssentiaCommand {
static String commandName = "teleportrequesthere";
@Override
public String commandName() {
return "teleportrequesthere";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(baseOtherCommandPermission()))
.executes((source) -> {
if (!(source.getSource().getSender() instanceof Player player))
return 1;

11
plugin/src/main/java/com/alttd/essentia/commands/player/TeleportRequestHereCommand.java
View File

@ -20,19 +20,22 @@ import java.util.List;
public class TeleportRequestHereCommand implements EssentiaCommand {
static String commandName = "teleportrequesthere";
@Override
public String commandName() {
return "teleportrequesthere";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
commandSourceStack.getSender() instanceof Player
)
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(baseOtherCommandPermission()))
.executes((source) -> {
if (!(source.getSource().getSender() instanceof Player player))
return 1;

11
plugin/src/main/java/com/alttd/essentia/commands/player/TeleportToggleCommand.java
View File

@ -21,14 +21,17 @@ import java.util.List;
public class TeleportToggleCommand implements EssentiaCommand {
static String commandName = "teleporttoggle";
@Override
public String commandName() {
return "teleporttoggle";
}
@Override
public @NotNull LiteralCommandNode<CommandSourceStack> command() {
final LiteralArgumentBuilder<CommandSourceStack> builder =
Commands.literal(commandName)
Commands.literal(commandName())
.requires(
commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName)
commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission())
)
.executes((source) -> {
if (source.getSource().getSender() instanceof Player player)
@ -38,7 +41,7 @@ public class TeleportToggleCommand implements EssentiaCommand {
})
.then(
Commands.argument("player", ArgumentTypes.player())
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName + ".other"))
.requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(baseOtherCommandPermission()))
.executes((source) -> {
CommandSourceStack sourceStack = source.getSource();
Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

3
plugin/src/main/java/com/alttd/essentia/configuration/Config.java
View File

@ -2,7 +2,6 @@ package com.alttd.essentia.configuration;
import com.alttd.essentia.EssentiaPlugin;
import com.google.common.base.Throwables;
import org.bukkit.Bukkit;
import org.bukkit.Sound;
import org.bukkit.configuration.InvalidConfigurationException;
import org.bukkit.configuration.file.YamlConfiguration;
@ -66,7 +65,7 @@ public class Config {
saveConfig();
}
static void saveConfig() {
public static void saveConfig() {
try {
config.save(CONFIG_FILE);
} catch (IOException ex) {