src/main/java/com/irtimaled/bbor/client/commands/ConfigCommand.java

   1 package com.irtimaled.bbor.client.commands;
   2
   3 import com.irtimaled.bbor.client.config.ConfigManager;
   4 import com.irtimaled.bbor.client.config.Setting;
   5 import com.irtimaled.bbor.client.gui.SettingsScreen;
   6 import com.mojang.brigadier.Command;
   7 import com.mojang.brigadier.CommandDispatcher;
   8 import com.mojang.brigadier.arguments.ArgumentType;
   9 import com.mojang.brigadier.builder.LiteralArgumentBuilder;
  10 import net.minecraft.command.CommandSource;
  11 import net.minecraft.command.Commands;
  12 import net.minecraft.command.ISuggestionProvider;
  13
  14 import java.util.function.Function;
  15
  16 public class ConfigCommand {
  17     private static final String COMMAND = "bbor:config";
  18     private static final String GET = "get";
  19     private static final String SAVE = "save";
  20     private static final String SHOW_GUI = "showGui";
  21     private static final String VALUE = "value";
  22     private static final String RESET = "reset";
  23
  24     public static void register(CommandDispatcher<ISuggestionProvider> commandDispatcher) {
  25         LiteralArgumentBuilder command = Commands.literal(COMMAND)
  26                 .then(buildCommands(GET, ConfigCommand::getCommandForSetting))
  27                 .then(buildCommands(ArgumentNames.SET, ConfigCommand::setCommandForSetting))
  28                 .then(buildCommands(RESET, ConfigCommand::resetCommandForSetting)
  29                         .executes(context1 -> {
  30                             ConfigManager.getSettings().forEach(Setting::reset);
  31                             ConfigManager.saveConfig();
  32                             return 0;
  33                         }))
  34                 .then(Commands.literal(SAVE)
  35                         .executes(context -> {
  36                             ConfigManager.saveConfig();
  37                             return 0;
  38                         }))
  39                 .then(Commands.literal(SHOW_GUI)
  40                         .executes(context -> {
  41                             SettingsScreen.show();
  42                             return 0;
  43                         }));
  44
  45         commandDispatcher.register(command);
  46     }
  47
  48     private static LiteralArgumentBuilder<CommandSource> resetCommandForSetting(Setting<?> setting) {
  49         return Commands.literal(setting.getName())
  50                 .executes(context -> {
  51                     setting.reset();
  52                     ConfigManager.saveConfig();
  53                     return 0;
  54                 });
  55     }
  56
  57     private interface CommandBuilder extends Function<Setting<?>, LiteralArgumentBuilder<CommandSource>> {
  58     }
  59
  60     private static LiteralArgumentBuilder<CommandSource> buildCommands(String commandName, CommandBuilder commandBuilder) {
  61         LiteralArgumentBuilder<CommandSource> command = Commands.literal(commandName);
  62         for (Setting<?> setting : ConfigManager.getSettings()) {
  63             command.then(commandBuilder.apply(setting));
  64         }
  65         return command;
  66     }
  67
  68     private static LiteralArgumentBuilder<CommandSource> getCommandForSetting(Setting<?> setting) {
  69         return Commands.literal(setting.getName())
  70                 .executes(context -> {
  71                     CommandHelper.feedback(context, "%s: %s", setting.getName(), setting.get());
  72                     return 0;
  73                 });
  74     }
  75
  76     private static LiteralArgumentBuilder<CommandSource> setCommandForSetting(Setting<?> setting) {
  77         LiteralArgumentBuilder<CommandSource> command = Commands.literal(setting.getName());
  78         switch (setting.getType()) {
  79             case 'B':
  80                 buildSetSettingCommand(command, (Setting<Boolean>) setting, Arguments.bool(), Boolean.class);
  81                 break;
  82             case 'I':
  83                 buildSetSettingCommand(command, (Setting<Integer>) setting, Arguments.integer(), Integer.class);
  84                 break;
  85             case 'S':
  86                 buildSetSettingCommand(command, (Setting<String>) setting, Arguments.string(), String.class);
  87                 break;
  88         }
  89         return command;
  90     }
  91
  92     private static <T> void buildSetSettingCommand(LiteralArgumentBuilder<CommandSource> command,
  93                                                    Setting<T> setting, ArgumentType<T> argument, Class<T> clazz) {
  94         Command<CommandSource> setSettingCommand = context -> {
  95             setting.set(context.getArgument(VALUE, clazz));
  96             if (CommandHelper.lastNodeIsLiteral(context, SAVE)) {
  97                 ConfigManager.saveConfig();
  98             }
  99             return 0;
 100         };
 101         command.then(Commands.argument(VALUE, argument)
 102                 .executes(setSettingCommand)
 103                 .then(Commands.literal(SAVE)
 104                         .executes(setSettingCommand)));
 105     }
 106 }