231 lines
13 KiB
Java
231 lines
13 KiB
Java
package net.minecraft.server.commands;
|
|
|
|
import com.google.common.collect.Lists;
|
|
import com.mojang.brigadier.CommandDispatcher;
|
|
import com.mojang.brigadier.arguments.StringArgumentType;
|
|
import com.mojang.brigadier.context.CommandContext;
|
|
import com.mojang.brigadier.exceptions.CommandSyntaxException;
|
|
import com.mojang.brigadier.exceptions.Dynamic2CommandExceptionType;
|
|
import com.mojang.brigadier.exceptions.DynamicCommandExceptionType;
|
|
import com.mojang.brigadier.suggestion.SuggestionProvider;
|
|
import com.mojang.brigadier.suggestion.SuggestionsBuilder;
|
|
import java.util.Collection;
|
|
import java.util.List;
|
|
import java.util.stream.Collectors;
|
|
import net.minecraft.commands.CommandSourceStack;
|
|
import net.minecraft.commands.Commands;
|
|
import net.minecraft.commands.SharedSuggestionProvider;
|
|
import net.minecraft.network.chat.Component;
|
|
import net.minecraft.network.chat.ComponentUtils;
|
|
import net.minecraft.server.packs.repository.Pack;
|
|
import net.minecraft.server.packs.repository.PackRepository;
|
|
import net.minecraft.server.packs.repository.PackSource;
|
|
import net.minecraft.world.flag.FeatureFlagSet;
|
|
import net.minecraft.world.flag.FeatureFlags;
|
|
|
|
public class DataPackCommand {
|
|
private static final DynamicCommandExceptionType ERROR_UNKNOWN_PACK = new DynamicCommandExceptionType(
|
|
p_308647_ -> Component.translatableEscape("commands.datapack.unknown", p_308647_)
|
|
);
|
|
private static final DynamicCommandExceptionType ERROR_PACK_ALREADY_ENABLED = new DynamicCommandExceptionType(
|
|
p_308646_ -> Component.translatableEscape("commands.datapack.enable.failed", p_308646_)
|
|
);
|
|
private static final DynamicCommandExceptionType ERROR_PACK_ALREADY_DISABLED = new DynamicCommandExceptionType(
|
|
p_308645_ -> Component.translatableEscape("commands.datapack.disable.failed", p_308645_)
|
|
);
|
|
private static final DynamicCommandExceptionType ERROR_CANNOT_DISABLE_FEATURE = new DynamicCommandExceptionType(
|
|
p_326235_ -> Component.translatableEscape("commands.datapack.disable.failed.feature", p_326235_)
|
|
);
|
|
private static final Dynamic2CommandExceptionType ERROR_PACK_FEATURES_NOT_ENABLED = new Dynamic2CommandExceptionType(
|
|
(p_308643_, p_308644_) -> Component.translatableEscape("commands.datapack.enable.failed.no_flags", p_308643_, p_308644_)
|
|
);
|
|
private static final SuggestionProvider<CommandSourceStack> SELECTED_PACKS = (p_136848_, p_136849_) -> SharedSuggestionProvider.suggest(
|
|
p_136848_.getSource().getServer().getPackRepository().getSelectedIds().stream().map(StringArgumentType::escapeIfRequired), p_136849_
|
|
);
|
|
private static final SuggestionProvider<CommandSourceStack> UNSELECTED_PACKS = (p_248113_, p_248114_) -> {
|
|
PackRepository packrepository = p_248113_.getSource().getServer().getPackRepository();
|
|
Collection<String> collection = packrepository.getSelectedIds();
|
|
FeatureFlagSet featureflagset = p_248113_.getSource().enabledFeatures();
|
|
return SharedSuggestionProvider.suggest(
|
|
packrepository.getAvailablePacks()
|
|
.stream()
|
|
.filter(p_248116_ -> p_248116_.getRequestedFeatures().isSubsetOf(featureflagset))
|
|
.map(Pack::getId)
|
|
.filter(p_250072_ -> !collection.contains(p_250072_))
|
|
.map(StringArgumentType::escapeIfRequired),
|
|
p_248114_
|
|
);
|
|
};
|
|
|
|
public static void register(CommandDispatcher<CommandSourceStack> p_136809_) {
|
|
p_136809_.register(
|
|
Commands.literal("datapack")
|
|
.requires(p_136872_ -> p_136872_.hasPermission(2))
|
|
.then(
|
|
Commands.literal("enable")
|
|
.then(
|
|
Commands.argument("name", StringArgumentType.string())
|
|
.suggests(UNSELECTED_PACKS)
|
|
.executes(
|
|
p_136876_ -> enablePack(
|
|
p_136876_.getSource(),
|
|
getPack(p_136876_, "name", true),
|
|
(p_180059_, p_180060_) -> p_180060_.getDefaultPosition().insert(p_180059_, p_180060_, Pack::selectionConfig, false)
|
|
)
|
|
)
|
|
.then(
|
|
Commands.literal("after")
|
|
.then(
|
|
Commands.argument("existing", StringArgumentType.string())
|
|
.suggests(SELECTED_PACKS)
|
|
.executes(
|
|
p_136880_ -> enablePack(
|
|
p_136880_.getSource(),
|
|
getPack(p_136880_, "name", true),
|
|
(p_180056_, p_180057_) -> p_180056_.add(
|
|
p_180056_.indexOf(getPack(p_136880_, "existing", false)) + 1, p_180057_
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
.then(
|
|
Commands.literal("before")
|
|
.then(
|
|
Commands.argument("existing", StringArgumentType.string())
|
|
.suggests(SELECTED_PACKS)
|
|
.executes(
|
|
p_136878_ -> enablePack(
|
|
p_136878_.getSource(),
|
|
getPack(p_136878_, "name", true),
|
|
(p_180046_, p_180047_) -> p_180046_.add(
|
|
p_180046_.indexOf(getPack(p_136878_, "existing", false)), p_180047_
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
.then(
|
|
Commands.literal("last")
|
|
.executes(p_136874_ -> enablePack(p_136874_.getSource(), getPack(p_136874_, "name", true), List::add))
|
|
)
|
|
.then(
|
|
Commands.literal("first")
|
|
.executes(
|
|
p_136882_ -> enablePack(
|
|
p_136882_.getSource(),
|
|
getPack(p_136882_, "name", true),
|
|
(p_180052_, p_180053_) -> p_180052_.add(0, p_180053_)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
.then(
|
|
Commands.literal("disable")
|
|
.then(
|
|
Commands.argument("name", StringArgumentType.string())
|
|
.suggests(SELECTED_PACKS)
|
|
.executes(p_136870_ -> disablePack(p_136870_.getSource(), getPack(p_136870_, "name", false)))
|
|
)
|
|
)
|
|
.then(
|
|
Commands.literal("list")
|
|
.executes(p_136864_ -> listPacks(p_136864_.getSource()))
|
|
.then(Commands.literal("available").executes(p_136846_ -> listAvailablePacks(p_136846_.getSource())))
|
|
.then(Commands.literal("enabled").executes(p_136811_ -> listEnabledPacks(p_136811_.getSource())))
|
|
)
|
|
);
|
|
}
|
|
|
|
private static int enablePack(CommandSourceStack p_136829_, Pack p_136830_, DataPackCommand.Inserter p_136831_) throws CommandSyntaxException {
|
|
PackRepository packrepository = p_136829_.getServer().getPackRepository();
|
|
List<Pack> list = Lists.newArrayList(packrepository.getSelectedPacks());
|
|
p_136831_.apply(list, p_136830_);
|
|
p_136829_.sendSuccess(() -> Component.translatable("commands.datapack.modify.enable", p_136830_.getChatLink(true)), true);
|
|
ReloadCommand.reloadPacks(list.stream().map(Pack::getId).collect(Collectors.toList()), p_136829_);
|
|
return list.size();
|
|
}
|
|
|
|
private static int disablePack(CommandSourceStack p_136826_, Pack p_136827_) {
|
|
PackRepository packrepository = p_136826_.getServer().getPackRepository();
|
|
List<Pack> list = Lists.newArrayList(packrepository.getSelectedPacks());
|
|
list.remove(p_136827_);
|
|
p_136826_.sendSuccess(() -> Component.translatable("commands.datapack.modify.disable", p_136827_.getChatLink(true)), true);
|
|
ReloadCommand.reloadPacks(list.stream().map(Pack::getId).collect(Collectors.toList()), p_136826_);
|
|
return list.size();
|
|
}
|
|
|
|
private static int listPacks(CommandSourceStack p_136824_) {
|
|
return listEnabledPacks(p_136824_) + listAvailablePacks(p_136824_);
|
|
}
|
|
|
|
private static int listAvailablePacks(CommandSourceStack p_136855_) {
|
|
PackRepository packrepository = p_136855_.getServer().getPackRepository();
|
|
packrepository.reload();
|
|
Collection<Pack> collection = packrepository.getSelectedPacks();
|
|
Collection<Pack> collection1 = packrepository.getAvailablePacks();
|
|
FeatureFlagSet featureflagset = p_136855_.enabledFeatures();
|
|
List<Pack> list = collection1.stream().filter(p_248121_ -> !collection.contains(p_248121_) && p_248121_.getRequestedFeatures().isSubsetOf(featureflagset)).toList();
|
|
if (list.isEmpty()) {
|
|
p_136855_.sendSuccess(() -> Component.translatable("commands.datapack.list.available.none"), false);
|
|
} else {
|
|
p_136855_.sendSuccess(
|
|
() -> Component.translatable(
|
|
"commands.datapack.list.available.success", list.size(), ComponentUtils.formatList(list, p_136844_ -> p_136844_.getChatLink(false))
|
|
),
|
|
false
|
|
);
|
|
}
|
|
|
|
return list.size();
|
|
}
|
|
|
|
private static int listEnabledPacks(CommandSourceStack p_136866_) {
|
|
PackRepository packrepository = p_136866_.getServer().getPackRepository();
|
|
packrepository.reload();
|
|
Collection<? extends Pack> collection = packrepository.getSelectedPacks();
|
|
if (collection.isEmpty()) {
|
|
p_136866_.sendSuccess(() -> Component.translatable("commands.datapack.list.enabled.none"), false);
|
|
} else {
|
|
p_136866_.sendSuccess(
|
|
() -> Component.translatable(
|
|
"commands.datapack.list.enabled.success", collection.size(), ComponentUtils.formatList(collection, p_136807_ -> p_136807_.getChatLink(true))
|
|
),
|
|
false
|
|
);
|
|
}
|
|
|
|
return collection.size();
|
|
}
|
|
|
|
private static Pack getPack(CommandContext<CommandSourceStack> p_136816_, String p_136817_, boolean p_136818_) throws CommandSyntaxException {
|
|
String s = StringArgumentType.getString(p_136816_, p_136817_);
|
|
PackRepository packrepository = p_136816_.getSource().getServer().getPackRepository();
|
|
Pack pack = packrepository.getPack(s);
|
|
if (pack == null) {
|
|
throw ERROR_UNKNOWN_PACK.create(s);
|
|
} else {
|
|
boolean flag = packrepository.getSelectedPacks().contains(pack);
|
|
if (p_136818_ && flag) {
|
|
throw ERROR_PACK_ALREADY_ENABLED.create(s);
|
|
} else if (!p_136818_ && !flag) {
|
|
throw ERROR_PACK_ALREADY_DISABLED.create(s);
|
|
} else {
|
|
FeatureFlagSet featureflagset = p_136816_.getSource().enabledFeatures();
|
|
FeatureFlagSet featureflagset1 = pack.getRequestedFeatures();
|
|
if (!p_136818_ && !featureflagset1.isEmpty() && pack.getPackSource() == PackSource.FEATURE) {
|
|
throw ERROR_CANNOT_DISABLE_FEATURE.create(s);
|
|
} else if (!featureflagset1.isSubsetOf(featureflagset)) {
|
|
throw ERROR_PACK_FEATURES_NOT_ENABLED.create(s, FeatureFlags.printMissingFlags(featureflagset, featureflagset1));
|
|
} else {
|
|
return pack;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
interface Inserter {
|
|
void apply(List<Pack> p_136884_, Pack p_136885_) throws CommandSyntaxException;
|
|
}
|
|
} |