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