diff --git a/src/common/resources/lang/en_US/command.lang b/src/common/resources/lang/en_US/command.lang
index dc37e72b7..af0dff9c6 100644
--- a/src/common/resources/lang/en_US/command.lang
+++ b/src/common/resources/lang/en_US/command.lang
@@ -41,6 +41,11 @@ command.argument_types.entity.selector.options.z.description=z position
 command.argument_types.entity.selector.options.dx.description=Entities between x and x + dx
 command.argument_types.entity.selector.options.dy.description=Entities between y and y + dy
 command.argument_types.entity.selector.options.dz.description=Entities between z and z + dz
+
+command.argument_types.sound_id.invalid_id=Invalid or unknown sound id '%s'
+
+command.argument_types.sound_category.invalid_name=Invalid or unknown sound category '%s'
+
 command.exceptions.tag.valueless=Expected value for tag key '%s'
 command.argument_types.item_stack.tag.invalid=Invalid tag key value; must be an integer, floating point, double-precision floating point, boolean or string value
 command.exceptions.metadata.unterminated=Expected end of metadata
@@ -160,4 +165,40 @@ command.commands.heal.success_single=Healed %s entity
 command.commands.heal.success_multiple=Healed %s entities
 command.commands.playsound.success=Played sound %s in category %s at %s, %s, %s
 command.commands.playsound.exception_failure=Could not play sound %s
-command.commands.spawnparticle.success=Spawned particle %s at %s, %s, %s
\ No newline at end of file
+command.commands.spawnparticle.success=Spawned particle %s at %s, %s, %s
+
+command.commands.ban.ip.success=Banned ip '%s'
+command.commands.ban.username.success=Banned player '%s'
+command.commands.ban.username.fail.wrong_name=Can't find player for '%s'
+command.commands.ban.exception_failure=Failed to ban '%s'
+
+command.commands.unban.ip.success=Unbanned ip '%s'
+command.commands.unban.username.success=Unbanned player '%s'
+command.commands.unban.username.fail.wrong_name=Can't find player for '%s'
+command.commands.unban.exception_failure=Failed to unban '%s'
+
+command.commands.kick.success=Kicked player '%s'
+command.commands.kick.exception_failure=Failed to kick '%s'
+
+command.commands.whitelist.on.success=Turning on whitelist
+command.commands.whitelist.off.success=Turning off whitelist
+command.commands.whitelist.list=Whitelisted players: %s
+command.commands.whitelist.reload=Reloading whitelist
+command.commands.whitelist.add.success=Added '%s' to the whitelist
+command.commands.whitelist.add.fail.wrong_name=Failed to add '%s' to whitelist
+command.commands.whitelist.remove.success=Removed '%s' from the whitelist
+command.commands.whitelist.remove.fail.wrong_name=Failed to remove '%s' from whitelist
+command.commands.whitelist.exception_failure=Failed to process whitelist command for '%s'
+
+#command.commands.save.exception_failure
+command.commands.save.start=Starting forced save
+command.commands.save.end=Saving complete
+command.commands.save.on=Enabling auto saving
+command.commands.save.off=Disabling auto saving
+command.commands.save.interval=Setting save interval to %s
+command.commands.save.amount=Setting max chunks saved to %s
+
+#command.commands.mobspawning.exception_failure
+command.commands.mobspawning.set=Set %s to %s
+command.commands.mobspawning.passive=Passive spawning set to %s
+command.commands.mobspawning.hostile=Hostile spawning set to %s
\ No newline at end of file
diff --git a/src/common/resources/lang/en_US/options.lang b/src/common/resources/lang/en_US/options.lang
index 05c5b165e..734ffc136 100644
--- a/src/common/resources/lang/en_US/options.lang
+++ b/src/common/resources/lang/en_US/options.lang
@@ -166,6 +166,10 @@ options.loadAllSounds=Load All Sounds
 options.allowSoundOverrides=Allow Sound Overrides
 options.downloadSoundfiles=Download Sound Files
 options.subtitles=Subtitles
+options.chatVisibility=Chat Visibility
+options.chatVisibility.show_all=Always Show
+options.chatVisibility.show_when_chatting=Only Show When Chatting
+options.chatVisibility.never_show=Never Show
 
 options.tooltipStyle.default=Default
 options.tooltipStyle.modern=Modern
diff --git a/src/main/java/net/minecraft/client/gui/hud/IngameHud.java b/src/main/java/net/minecraft/client/gui/hud/IngameHud.java
index 8f9129b6a..c4e3f7aaa 100644
--- a/src/main/java/net/minecraft/client/gui/hud/IngameHud.java
+++ b/src/main/java/net/minecraft/client/gui/hud/IngameHud.java
@@ -15,6 +15,7 @@ import net.minecraft.client.gui.chat.ChatScreen;
 import net.minecraft.client.gui.Gui;
 import net.minecraft.client.gui.HeldItemTooltipElement;
 import net.minecraft.client.gui.PhotoModeScreen;
+import net.minecraft.core.enums.ChatVisibility;
 import net.minecraft.core.util.helper.Direction;
 import org.lwjgl.opengl.GL11;
 
@@ -799,6 +800,7 @@ public class IngameHud extends Gui
 
     public void drawChat(int width, int height, int sp)
     {
+        if (mc.gameSettings.chatVisibility.value == ChatVisibility.NEVER_SHOW) return;
         int messagesToShow = 10;
         boolean ignoreFadeout = false;
         if (mc.currentScreen instanceof ChatScreen)
@@ -806,6 +808,8 @@ public class IngameHud extends Gui
             int acceptableSize = height - 48 - 48;
             messagesToShow = acceptableSize / 9;
             ignoreFadeout = true;
+        } else if (mc.gameSettings.chatVisibility.value == ChatVisibility.SHOW_WHEN_CHATTING) {
+            return;
         }
 
         if (chatScroll > chatMessageList.size() - messagesToShow) chatScroll = chatMessageList.size() - messagesToShow;
diff --git a/src/main/java/net/minecraft/client/gui/options/data/OptionsPages.java b/src/main/java/net/minecraft/client/gui/options/data/OptionsPages.java
index 706121948..e29f71aee 100644
--- a/src/main/java/net/minecraft/client/gui/options/data/OptionsPages.java
+++ b/src/main/java/net/minecraft/client/gui/options/data/OptionsPages.java
@@ -55,6 +55,7 @@ public abstract class OptionsPages
             .withComponent(new IntegerOptionComponent(mc.gameSettings.guiScale))
             .withComponent(new FloatOptionComponent(mc.gameSettings.screenPadding))
             .withComponent(new TooltipPickerComponent<>(mc.gameSettings.tooltipStyle))
+            .withComponent(new ToggleableOptionComponent<>(mc.gameSettings.chatVisibility))
             .withComponent(new BooleanOptionComponent(mc.gameSettings.fpsInOverlay))
             .withComponent(new BooleanOptionComponent(mc.gameSettings.versionInOverlay))
             .withComponent(new BooleanOptionComponent(mc.gameSettings.foodHealthRegenOverlay))
diff --git a/src/main/java/net/minecraft/client/option/GameSettings.java b/src/main/java/net/minecraft/client/option/GameSettings.java
index 277fef93f..26755d91e 100644
--- a/src/main/java/net/minecraft/client/option/GameSettings.java
+++ b/src/main/java/net/minecraft/client/option/GameSettings.java
@@ -17,6 +17,7 @@ import net.minecraft.client.discord.RichPresenceHandlerThread;
 import net.minecraft.client.gui.hud.component.HudComponents;
 import net.minecraft.client.input.InputDevice;
 import net.minecraft.client.option.enums.Colorblindness;
+import net.minecraft.core.enums.ChatVisibility;
 import net.minecraft.core.enums.Difficulty;
 import net.minecraft.client.option.enums.LightmapStyle;
 import net.minecraft.client.option.enums.MipmapType;
@@ -108,6 +109,7 @@ public class GameSettings {
 	public IntegerOption thirdPersonView = new IntegerOption(this, "thirdPersonView", 0);
 	public RangeOption renderDistance = new RangeOption(this, "renderDistance", 8, 2, 64);
 	public BooleanOption enableVsync = new BooleanOption(this, "enableVsync", false);
+	public EnumOption<ChatVisibility> chatVisibility = new EnumOption<>(this, "chatVisibility", ChatVisibility.class, ChatVisibility.SHOW_ALL);
 	public RangeOption customFpsLimit = new RangeOption(this,"customFpsLimit",0,241);
 	public IntegerOption guiScale = new IntegerOption(this, "guiScale", 0);
 	public IntegerOption overlayMode = new IntegerOption(this, "overlayMode", 0);
diff --git a/src/main/java/net/minecraft/core/enums/ChatVisibility.java b/src/main/java/net/minecraft/core/enums/ChatVisibility.java
new file mode 100644
index 000000000..8ac7db58b
--- /dev/null
+++ b/src/main/java/net/minecraft/core/enums/ChatVisibility.java
@@ -0,0 +1,7 @@
+package net.minecraft.core.enums;
+
+public enum ChatVisibility {
+    SHOW_ALL,
+    SHOW_WHEN_CHATTING,
+    NEVER_SHOW;
+}
diff --git a/src/main/java/net/minecraft/core/net/command/CommandManager.java b/src/main/java/net/minecraft/core/net/command/CommandManager.java
index 3cd797ba5..8cd63de4f 100644
--- a/src/main/java/net/minecraft/core/net/command/CommandManager.java
+++ b/src/main/java/net/minecraft/core/net/command/CommandManager.java
@@ -49,6 +49,8 @@ public class CommandManager {
         TestForCommand.register(DISPATCHER);
         DamageCommand.register(DISPATCHER);
         HealCommand.register(DISPATCHER);
+        MobSpawningCommand.register(DISPATCHER);
+        PlaySoundCommand.register(DISPATCHER);
 
         if (this.isServer) {
             StopCommand.register(DISPATCHER);
@@ -62,6 +64,11 @@ public class CommandManager {
             ScoreCommand.register(DISPATCHER);
             MeCommand.register(DISPATCHER);
             EmotesCommand.register(DISPATCHER);
+            BanCommand.register(DISPATCHER);
+            UnbanCommand.register(DISPATCHER);
+            KickCommand.register(DISPATCHER);
+            WhitelistCommand.register(DISPATCHER);
+            SaveCommand.register(DISPATCHER);
             for (CommandRegistry registry : externalServerCommands) {
                 registry.register(DISPATCHER);
             }
diff --git a/src/main/java/net/minecraft/core/net/command/arguments/SoundCategoryArgumentType.java b/src/main/java/net/minecraft/core/net/command/arguments/SoundCategoryArgumentType.java
new file mode 100644
index 000000000..7db0ab24a
--- /dev/null
+++ b/src/main/java/net/minecraft/core/net/command/arguments/SoundCategoryArgumentType.java
@@ -0,0 +1,51 @@
+package net.minecraft.core.net.command.arguments;
+
+import com.mojang.brigadier.StringReader;
+import com.mojang.brigadier.arguments.ArgumentType;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+import net.minecraft.core.lang.I18n;
+import net.minecraft.core.sound.SoundCategory;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.CompletableFuture;
+
+public class SoundCategoryArgumentType implements ArgumentType<SoundCategory> {
+    private static final List<String> EXAMPLES = Arrays.asList("MUSIC", "WORLD_SOUNDS", "WEATHER_SOUNDS");
+
+    public static ArgumentType<SoundCategory> soundCategory() {
+        return new SoundCategoryArgumentType();
+    }
+
+    @Override
+    public SoundCategory parse(StringReader reader) throws CommandSyntaxException {
+        final String string = reader.readString();
+
+        for (SoundCategory category : SoundCategory.values()) {
+            if (category.name().equalsIgnoreCase(string)) {
+                return category;
+            }
+        }
+        throw new CommandSyntaxException(CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownArgument(), () -> I18n.getInstance().translateKeyAndFormat("command.argument_types.sound_category.invalid_name", string));
+    }
+
+    @Override
+    public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
+        for (SoundCategory category : SoundCategory.values()) {
+            if (category.name().toLowerCase(Locale.ROOT).startsWith(builder.getRemainingLowerCase())) {
+                builder.suggest(category.name());
+            }
+        }
+        return builder.buildFuture();
+    }
+
+    @Override
+    public Collection<String> getExamples() {
+        return EXAMPLES;
+    }
+}
diff --git a/src/main/java/net/minecraft/core/net/command/arguments/SoundIdArgumentType.java b/src/main/java/net/minecraft/core/net/command/arguments/SoundIdArgumentType.java
new file mode 100644
index 000000000..342cf8f3b
--- /dev/null
+++ b/src/main/java/net/minecraft/core/net/command/arguments/SoundIdArgumentType.java
@@ -0,0 +1,66 @@
+package net.minecraft.core.net.command.arguments;
+
+import com.mojang.brigadier.StringReader;
+import com.mojang.brigadier.arguments.ArgumentType;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+import net.minecraft.client.sound.SoundEvent;
+import net.minecraft.client.sound.SoundRepository;
+import net.minecraft.core.Global;
+import net.minecraft.core.lang.I18n;
+import net.minecraft.core.sound.SoundTypes;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+public class SoundIdArgumentType implements ArgumentType<String> {
+    private static final List<String> EXAMPLES = Arrays.asList("random.fuse.lit", "note.snare", "mob.skeletonhurt");
+
+    public static ArgumentType<String> soundId() {
+        return new SoundIdArgumentType();
+    }
+
+    @Override
+    public String parse(StringReader reader) throws CommandSyntaxException {
+        final String string = reader.readString();
+
+        for (String se : soundIds()) {
+            if (se.equalsIgnoreCase(string)) {
+                return string;
+            }
+        }
+        throw new CommandSyntaxException(CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownArgument(), () -> I18n.getInstance().translateKeyAndFormat("command.argument_types.sound_id.invalid_id", string));
+    }
+
+    @Override
+    public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
+        for (String se : soundIds()) {
+            if (se.startsWith(builder.getRemainingLowerCase())) {
+                builder.suggest(se);
+            }
+        }
+        return builder.buildFuture();
+    }
+
+    public Collection<String> soundIds() {
+        if (Global.isServer) {
+            return SoundTypes.getSoundIds().keySet();
+        } else {
+            List<String> ids = new ArrayList<>();
+            for (SoundEvent e : SoundRepository.SOUNDS.getAllEvents()) {
+                ids.add(e.getEventID());
+            }
+            return ids;
+        }
+    }
+
+    @Override
+    public Collection<String> getExamples() {
+        return EXAMPLES;
+    }
+}
diff --git a/src/main/java/net/minecraft/core/net/command/commands/MobSpawningCommand.java b/src/main/java/net/minecraft/core/net/command/commands/MobSpawningCommand.java
new file mode 100644
index 000000000..462d35345
--- /dev/null
+++ b/src/main/java/net/minecraft/core/net/command/commands/MobSpawningCommand.java
@@ -0,0 +1,77 @@
+package net.minecraft.core.net.command.commands;
+
+import com.mojang.brigadier.Command;
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.arguments.BoolArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.builder.RequiredArgumentBuilder;
+import com.mojang.brigadier.exceptions.DynamicCommandExceptionType;
+import net.minecraft.core.entity.Entity;
+import net.minecraft.core.entity.EntityDispatcher;
+import net.minecraft.core.lang.I18n;
+import net.minecraft.core.net.command.CommandSource;
+import net.minecraft.core.net.command.arguments.EntitySummonArgumentType;
+import net.minecraft.core.world.SpawnerMobs;
+import net.minecraft.core.world.World;
+
+import java.util.Collection;
+
+public class MobSpawningCommand {
+    private static final DynamicCommandExceptionType FAILURE =
+        new DynamicCommandExceptionType(arg -> () -> I18n.getInstance().translateKeyAndFormat("command.commands.mobspawning.exception_failure", arg));
+
+    public static void register(CommandDispatcher<CommandSource> dispatcher) {
+        dispatcher.register
+            (
+                LiteralArgumentBuilder.<CommandSource>literal("mobspawning")
+                    .requires(CommandSource::hasAdmin)
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("list").executes(c -> {
+                        Collection<String> ids = EntityDispatcher.classToKeyMap.values();
+                        World world = c.getSource().getWorld();
+                        SpawnerMobs.SpawnerConfig config = world.spawningConfig;
+                        for (String s : ids) {
+                            c.getSource().sendMessage(String.format("%s : %s", s, config.canMobSpawn(s)));
+                        }
+                        c.getSource().sendMessage("Passive Spawning : " + config.canPassiveSpawn(world));
+                        c.getSource().sendMessage("Hostile Spawning : " + config.canHostileSpawn(world));
+
+                        return Command.SINGLE_SUCCESS;
+                    }))
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("set")
+                        .then(RequiredArgumentBuilder.<CommandSource, Class<? extends Entity>>argument("entity", EntitySummonArgumentType.entity())
+                            .then(RequiredArgumentBuilder.<CommandSource, Boolean>argument("value", BoolArgumentType.bool())
+                                .executes(c -> {
+                                    World world = c.getSource().getWorld();
+                                    SpawnerMobs.SpawnerConfig config = world.spawningConfig;
+
+                                    String mobId = EntityDispatcher.getEncodeId(c.getArgument("entity", Class.class));
+                                    boolean value = c.getArgument("value", Boolean.class);
+                                    config.setMobSpawn(mobId, value);
+                                    c.getSource().sendTranslatableMessage("command.commands.mobspawning.set", mobId, value);
+                        return Command.SINGLE_SUCCESS;
+                    }))))
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("passive")
+                        .then(RequiredArgumentBuilder.<CommandSource, Boolean>argument("value", BoolArgumentType.bool())
+                            .executes(c -> {
+                                World world = c.getSource().getWorld();
+                                SpawnerMobs.SpawnerConfig config = world.spawningConfig;
+
+                                boolean value = c.getArgument("value", Boolean.class);
+                                config.setPassiveSpawning(value);
+                                c.getSource().sendTranslatableMessage("command.commands.mobspawning.passive", value);
+                                return Command.SINGLE_SUCCESS;
+                            })))
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("hostile")
+                        .then(RequiredArgumentBuilder.<CommandSource, Boolean>argument("value", BoolArgumentType.bool())
+                            .executes(c -> {
+                                World world = c.getSource().getWorld();
+                                SpawnerMobs.SpawnerConfig config = world.spawningConfig;
+
+                                boolean value = c.getArgument("value", Boolean.class);
+                                config.setHostileSpawning(value);
+                                c.getSource().sendTranslatableMessage("command.commands.mobspawning.hostile", value);
+                                return Command.SINGLE_SUCCESS;
+                            })))
+            );
+    }
+}
diff --git a/src/main/java/net/minecraft/core/net/command/commands/PlaySoundCommand.java b/src/main/java/net/minecraft/core/net/command/commands/PlaySoundCommand.java
new file mode 100644
index 000000000..fa1a63021
--- /dev/null
+++ b/src/main/java/net/minecraft/core/net/command/commands/PlaySoundCommand.java
@@ -0,0 +1,138 @@
+package net.minecraft.core.net.command.commands;
+
+import com.mojang.brigadier.Command;
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.arguments.FloatArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.builder.RequiredArgumentBuilder;
+import net.minecraft.core.entity.Entity;
+import net.minecraft.core.entity.player.Player;
+import net.minecraft.core.net.command.CommandSource;
+import net.minecraft.core.net.command.arguments.EntityArgumentType;
+import net.minecraft.core.net.command.arguments.SoundCategoryArgumentType;
+import net.minecraft.core.net.command.arguments.SoundIdArgumentType;
+import net.minecraft.core.net.command.arguments.Vec3ArgumentType;
+import net.minecraft.core.net.command.helpers.DoubleCoordinates;
+import net.minecraft.core.net.command.helpers.EntitySelector;
+import net.minecraft.core.sound.SoundCategory;
+import net.minecraft.core.util.phys.Vec3;
+import net.minecraft.core.world.World;
+
+import java.util.List;
+
+public class PlaySoundCommand {
+    public static void register(CommandDispatcher<CommandSource> dispatcher) {
+        dispatcher.register
+            (
+                LiteralArgumentBuilder.<CommandSource>literal("playsound")
+                    .requires(CommandSource::hasAdmin)
+                    .then(RequiredArgumentBuilder.<CommandSource, String>argument("soundId", SoundIdArgumentType.soundId())
+                        .then(RequiredArgumentBuilder.<CommandSource, SoundCategory>argument("type", SoundCategoryArgumentType.soundCategory())
+                            .executes(c -> {
+                                String soundId = c.getArgument("soundId", String.class);
+                                SoundCategory category = c.getArgument("type", SoundCategory.class);
+                                Player player = c.getSource().getSender();
+                                World world = c.getSource().getWorld();
+                                if (player != null) {
+                                    world.playSoundEffect(player, category, player.x, player.y, player.z, soundId, 1f, 1f);
+                                    return Command.SINGLE_SUCCESS;
+                                }
+                                return 0;
+                            })
+                            .then(RequiredArgumentBuilder.<CommandSource, DoubleCoordinates>argument("position", Vec3ArgumentType.vec3d())
+                                .executes(c -> {
+                                    String soundId = c.getArgument("soundId", String.class);
+                                    SoundCategory category = c.getArgument("type", SoundCategory.class);
+                                    DoubleCoordinates coordinates = c.getArgument("position", DoubleCoordinates.class);
+
+                                    Vec3 coords = c.getSource().getCoordinates(true);
+                                    double sourceX = coords == null ? 0 : coords.x;
+                                    double sourceY = coords == null ? 0 : coords.y;
+                                    double sourceZ = coords == null ? 0 : coords.z;
+                                    World world = c.getSource().getWorld();
+                                    world.playSoundEffect(null, category, coordinates.getX(sourceX), coordinates.getY(sourceY), coordinates.getZ(sourceZ), soundId, 1f, 1f);
+                                    return Command.SINGLE_SUCCESS;
+                                })
+                                .then(RequiredArgumentBuilder.<CommandSource, Float>argument("volume", FloatArgumentType.floatArg())
+                                    .executes(c -> {
+                                        String soundId = c.getArgument("soundId", String.class);
+                                        SoundCategory category = c.getArgument("type", SoundCategory.class);
+                                        DoubleCoordinates coordinates = c.getArgument("position", DoubleCoordinates.class);
+                                        float volume = c.getArgument("volume", Float.class);
+
+                                        Vec3 coords = c.getSource().getCoordinates(true);
+                                        double sourceX = coords == null ? 0 : coords.x;
+                                        double sourceY = coords == null ? 0 : coords.y;
+                                        double sourceZ = coords == null ? 0 : coords.z;
+                                        World world = c.getSource().getWorld();
+                                        world.playSoundEffect(null, category, coordinates.getX(sourceX), coordinates.getY(sourceY), coordinates.getZ(sourceZ), soundId, volume, 1f);
+                                        return Command.SINGLE_SUCCESS;
+                                    })
+                                    .then(RequiredArgumentBuilder.<CommandSource, Float>argument("pitch", FloatArgumentType.floatArg())
+                                        .executes(c -> {
+                                            String soundId = c.getArgument("soundId", String.class);
+                                            SoundCategory category = c.getArgument("type", SoundCategory.class);
+                                            DoubleCoordinates coordinates = c.getArgument("position", DoubleCoordinates.class);
+                                            float volume = c.getArgument("volume", Float.class);
+                                            float pitch = c.getArgument("pitch", Float.class);
+
+                                            Vec3 coords = c.getSource().getCoordinates(true);
+                                            double sourceX = coords == null ? 0 : coords.x;
+                                            double sourceY = coords == null ? 0 : coords.y;
+                                            double sourceZ = coords == null ? 0 : coords.z;
+                                            World world = c.getSource().getWorld();
+                                            world.playSoundEffect(null, category, coordinates.getX(sourceX), coordinates.getY(sourceY), coordinates.getZ(sourceZ), soundId, volume, pitch);
+                                            return Command.SINGLE_SUCCESS;
+                                        })
+                                    )
+                                )
+                            )
+                            .then(RequiredArgumentBuilder.<CommandSource, EntitySelector>argument("target", EntityArgumentType.entities())
+                                .executes(c -> {
+                                    String soundId = c.getArgument("soundId", String.class);
+                                    SoundCategory category = c.getArgument("type", SoundCategory.class);
+                                    EntitySelector entitySelector = c.getArgument("target", EntitySelector.class);
+                                    List<? extends Entity> targets = entitySelector.get(c.getSource());
+
+                                    World world = c.getSource().getWorld();
+                                    for (Entity e : targets) {
+                                        world.playSoundEffect(null, category, e.x, e.y, e.z, soundId, 1f, 1f);
+                                    }
+                                    return Command.SINGLE_SUCCESS;
+                                })
+                                .then(RequiredArgumentBuilder.<CommandSource, Float>argument("volume", FloatArgumentType.floatArg())
+                                    .executes(c -> {
+                                        String soundId = c.getArgument("soundId", String.class);
+                                        SoundCategory category = c.getArgument("type", SoundCategory.class);
+                                        EntitySelector entitySelector = c.getArgument("target", EntitySelector.class);
+                                        List<? extends Entity> targets = entitySelector.get(c.getSource());
+                                        float volume = c.getArgument("volume", Float.class);
+
+                                        World world = c.getSource().getWorld();
+                                        for (Entity e : targets) {
+                                            world.playSoundEffect(null, category, e.x, e.y, e.z, soundId, volume, 1f);
+                                        }
+                                        return Command.SINGLE_SUCCESS;
+                                    })
+                                    .then(RequiredArgumentBuilder.<CommandSource, Float>argument("pitch", FloatArgumentType.floatArg())
+                                        .executes(c -> {
+                                            String soundId = c.getArgument("soundId", String.class);
+                                            SoundCategory category = c.getArgument("type", SoundCategory.class);
+                                            EntitySelector entitySelector = c.getArgument("target", EntitySelector.class);
+                                            List<? extends Entity> targets = entitySelector.get(c.getSource());
+                                            float volume = c.getArgument("volume", Float.class);
+                                            float pitch = c.getArgument("pitch", Float.class);
+
+                                            World world = c.getSource().getWorld();
+                                            for (Entity e : targets) {
+                                                world.playSoundEffect(null, category, e.x, e.y, e.z, soundId, volume, pitch);
+                                            }
+                                            return Command.SINGLE_SUCCESS;
+                                        })
+                                    )
+                                )
+                            )
+                        ))
+            );
+    }
+}
diff --git a/src/main/java/net/minecraft/core/net/command/commands/WeatherCommand.java b/src/main/java/net/minecraft/core/net/command/commands/WeatherCommand.java
index 863ed6fc4..dd823e5a2 100644
--- a/src/main/java/net/minecraft/core/net/command/commands/WeatherCommand.java
+++ b/src/main/java/net/minecraft/core/net/command/commands/WeatherCommand.java
@@ -11,11 +11,22 @@ import net.minecraft.core.world.weather.Weather;
 import net.minecraft.core.net.command.CommandSource;
 import net.minecraft.core.net.command.arguments.TimeArgumentType;
 import net.minecraft.core.net.command.arguments.WeatherArgumentType;
+import net.minecraft.core.world.weather.Weathers;
 
 public class WeatherCommand {
     public static void register(CommandDispatcher<CommandSource> dispatcher) {
         CommandNode<CommandSource> command = dispatcher.register(LiteralArgumentBuilder.<CommandSource>literal("weather")
                 .requires(CommandSource::hasAdmin)
+                .then(LiteralArgumentBuilder.<CommandSource>literal("clear")
+                    .executes(c -> {
+                        CommandSource source = c.getSource();
+                        World world = source.getWorld();
+                        Weather weather = Weathers.OVERWORLD_CLEAR;
+
+                        world.weatherManager.overrideWeather(weather);
+                        source.sendTranslatableMessage("command.commands.weather.success", weather.getTranslatedName());
+                        return Command.SINGLE_SUCCESS;
+                    }))
                 .then(RequiredArgumentBuilder.<CommandSource, Weather>argument("weather", WeatherArgumentType.weather())
                         .executes(c -> {
                             CommandSource source = c.getSource();
diff --git a/src/main/java/net/minecraft/server/net/PlayerList.java b/src/main/java/net/minecraft/server/net/PlayerList.java
index 237c9fd96..0b51157d1 100644
--- a/src/main/java/net/minecraft/server/net/PlayerList.java
+++ b/src/main/java/net/minecraft/server/net/PlayerList.java
@@ -42,7 +42,7 @@ public class PlayerList
     private final File opsFile;
     private final File whitelistFile;
     private PlayerIO playerIo;
-    private final boolean whitelistEnforced;
+    public boolean whitelistEnforced;
 
     AtomicInteger awaitedLoadThreads = new AtomicInteger(0);
 
diff --git a/src/main/java/net/minecraft/server/net/command/commands/BanCommand.java b/src/main/java/net/minecraft/server/net/command/commands/BanCommand.java
new file mode 100644
index 000000000..02a749722
--- /dev/null
+++ b/src/main/java/net/minecraft/server/net/command/commands/BanCommand.java
@@ -0,0 +1,76 @@
+package net.minecraft.server.net.command.commands;
+
+import com.mojang.brigadier.Command;
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.builder.RequiredArgumentBuilder;
+import com.mojang.brigadier.exceptions.DynamicCommandExceptionType;
+import net.minecraft.core.lang.I18n;
+import net.minecraft.core.net.command.CommandSource;
+import net.minecraft.core.net.command.exceptions.CommandExceptions;
+import net.minecraft.core.util.helper.UUIDHelper;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.entity.player.ServerPlayer;
+import net.minecraft.server.net.command.IServerCommandSource;
+
+public class BanCommand {
+    private static final DynamicCommandExceptionType FAILURE =
+        new DynamicCommandExceptionType(arg -> () -> I18n.getInstance().translateKeyAndFormat("command.commands.ban.exception_failure", arg));
+
+    public static void register(CommandDispatcher<CommandSource> dispatcher) {
+        dispatcher.register
+        (
+            LiteralArgumentBuilder.<CommandSource>literal("ban")
+                .requires(CommandSource::hasAdmin)
+                .then(LiteralArgumentBuilder.<CommandSource>literal("username")
+                    .then(RequiredArgumentBuilder.<CommandSource, String>argument("name", StringArgumentType.word()).executes(c -> {
+                        CommandSource source = c.getSource();
+                        if (!(source instanceof IServerCommandSource)) throw CommandExceptions.multiplayerWorldOnly().create();
+
+                        MinecraftServer server = ((IServerCommandSource)source).getServer();
+
+//                        String senderName = c.getSource().getName();
+                        String nameToBan = c.getArgument("name", String.class);
+                        ServerPlayer player = server.playerList.getPlayerEntity(nameToBan);
+                        if(player != null) {
+                            server.playerList.banPlayer(player.uuid);
+//                            sendNoticeToOps(senderName, "Banning " + nameToBan);
+                            c.getSource().sendTranslatableMessage("command.commands.ban.success", player.username);
+                            player.playerNetServerHandler.kickPlayer("Banned by admin");
+                        } else {
+                            UUIDHelper.runConversionAction(nameToBan, (uuid) -> {
+                                server.playerList.banPlayer(uuid);
+//                                sendNoticeToOps(senderName, "Banning " + nameToBan);
+                                c.getSource().sendTranslatableMessage("command.commands.ban.username.success", nameToBan);
+                            }, (username) -> {
+//                                handler.sendCommandFeedback(sender,"Could not retrieve UUID of player '" + username + "'");
+                                c.getSource().sendTranslatableMessage("command.commands.ban.username.fail.wrong_name", nameToBan);
+                            });
+                        }
+                        return Command.SINGLE_SUCCESS;
+                    })))
+                .then(LiteralArgumentBuilder.<CommandSource>literal("ip")
+                    .then(RequiredArgumentBuilder.<CommandSource, String>argument("address", StringArgumentType.word()).executes(c -> {
+                        CommandSource source = c.getSource();
+                        if (!(source instanceof IServerCommandSource)) throw CommandExceptions.multiplayerWorldOnly().create();
+
+                        MinecraftServer server = ((IServerCommandSource)source).getServer();
+
+//                        String senderName = c.getSource().getName();
+                        String ip = c.getArgument("address", String.class);
+                        server.playerList.banIP(ip);
+
+//                        sendNoticeToOps(senderName, "Banning ip " + ip);
+                        c.getSource().sendTranslatableMessage("command.commands.ban.ip.success", ip);
+//                        ServerPlayer player = server.playerList.getPlayerEntity(ip);
+//                        if(player != null)
+//                        {
+//                            player.playerNetServerHandler.kickPlayer("Banned by admin");
+//                        }
+                        return Command.SINGLE_SUCCESS;
+                    }))
+                )
+        );
+    }
+}
diff --git a/src/main/java/net/minecraft/server/net/command/commands/KickCommand.java b/src/main/java/net/minecraft/server/net/command/commands/KickCommand.java
new file mode 100644
index 000000000..642ccdc4b
--- /dev/null
+++ b/src/main/java/net/minecraft/server/net/command/commands/KickCommand.java
@@ -0,0 +1,44 @@
+package net.minecraft.server.net.command.commands;
+
+import com.mojang.brigadier.Command;
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.builder.RequiredArgumentBuilder;
+import com.mojang.brigadier.exceptions.DynamicCommandExceptionType;
+import net.minecraft.core.lang.I18n;
+import net.minecraft.core.net.command.CommandSource;
+import net.minecraft.core.net.command.arguments.EntityArgumentType;
+import net.minecraft.core.net.command.exceptions.CommandExceptions;
+import net.minecraft.core.net.command.helpers.EntitySelector;
+import net.minecraft.server.entity.player.ServerPlayer;
+import net.minecraft.server.net.command.IServerCommandSource;
+
+public class KickCommand {
+    private static final DynamicCommandExceptionType FAILURE =
+        new DynamicCommandExceptionType(arg -> () -> I18n.getInstance().translateKeyAndFormat("command.commands.kick.exception_failure", arg));
+
+    public static void register(CommandDispatcher<CommandSource> dispatcher) {
+        dispatcher.register
+            (
+                LiteralArgumentBuilder.<CommandSource>literal("kick")
+                    .requires(CommandSource::hasAdmin)
+                    .then(RequiredArgumentBuilder.<CommandSource, EntitySelector>argument("player", EntityArgumentType.player()).executes(c -> {
+                            CommandSource source = c.getSource();
+                            if (!(source instanceof IServerCommandSource)) throw CommandExceptions.multiplayerWorldOnly().create();
+
+                            EntitySelector entitySelector = c.getArgument("player", EntitySelector.class);
+                            ServerPlayer playerToKick = (ServerPlayer) entitySelector.get(source).get(0);
+                            if(playerToKick != null)
+                            {
+                                playerToKick.playerNetServerHandler.kickPlayer("Kicked by admin");
+//                                sendNoticeToOps(senderName, "Kicking " + playerToKick.getDisplayName());
+                                c.getSource().sendTranslatableMessage("command.commands.kick.success", playerToKick.username);
+                            } else
+                            {
+                                throw FAILURE.create(c.getArgument("player", String.class));
+                            }
+                            return Command.SINGLE_SUCCESS;
+                        }))
+            );
+    }
+}
diff --git a/src/main/java/net/minecraft/server/net/command/commands/SaveCommand.java b/src/main/java/net/minecraft/server/net/command/commands/SaveCommand.java
new file mode 100644
index 000000000..a52105084
--- /dev/null
+++ b/src/main/java/net/minecraft/server/net/command/commands/SaveCommand.java
@@ -0,0 +1,101 @@
+package net.minecraft.server.net.command.commands;
+
+import com.mojang.brigadier.Command;
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.builder.RequiredArgumentBuilder;
+import com.mojang.brigadier.exceptions.DynamicCommandExceptionType;
+import net.minecraft.core.lang.I18n;
+import net.minecraft.core.net.command.CommandSource;
+import net.minecraft.core.net.command.exceptions.CommandExceptions;
+import net.minecraft.core.world.Dimension;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.net.command.IServerCommandSource;
+import net.minecraft.server.world.WorldServer;
+
+public class SaveCommand {
+    private static final DynamicCommandExceptionType FAILURE =
+        new DynamicCommandExceptionType(arg -> () -> I18n.getInstance().translateKeyAndFormat("command.commands.save.exception_failure", arg));
+
+    public static void register(CommandDispatcher<CommandSource> dispatcher) {
+        dispatcher.register
+            (
+                LiteralArgumentBuilder.<CommandSource>literal("save")
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("all").executes(c -> {
+                        CommandSource source = c.getSource();
+                        if (!(source instanceof IServerCommandSource)) throw CommandExceptions.multiplayerWorldOnly().create();
+
+                        MinecraftServer server = ((IServerCommandSource)source).getServer();
+
+                        c.getSource().sendTranslatableMessage("command.commands.save.start");
+                        if(server.playerList != null) {
+                            server.playerList.savePlayerStates();
+                        }
+                        for(WorldServer worldServer : server.dimensionWorlds.values()) {
+                            worldServer.saveWorld(true, null, worldServer.dimension == Dimension.OVERWORLD);
+                        }
+                        c.getSource().sendTranslatableMessage("command.commands.save.end");
+
+                        return Command.SINGLE_SUCCESS;
+                    }))
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("on").executes(c -> {
+                        CommandSource source = c.getSource();
+                        if (!(source instanceof IServerCommandSource)) throw CommandExceptions.multiplayerWorldOnly().create();
+
+                        MinecraftServer server = ((IServerCommandSource)source).getServer();
+
+                        c.getSource().sendTranslatableMessage("command.commands.save.on");
+                        for(WorldServer worldServer : server.dimensionWorlds.values()) {
+                            worldServer.dontSave = false;
+                        }
+
+                        return Command.SINGLE_SUCCESS;
+                    }))
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("off").executes(c -> {
+                        CommandSource source = c.getSource();
+                        if (!(source instanceof IServerCommandSource)) throw CommandExceptions.multiplayerWorldOnly().create();
+
+                        MinecraftServer server = ((IServerCommandSource)source).getServer();
+
+                        c.getSource().sendTranslatableMessage("command.commands.save.off");
+                        for(WorldServer worldServer : server.dimensionWorlds.values()) {
+                            worldServer.dontSave = true;
+                        }
+
+                        return Command.SINGLE_SUCCESS;
+                    }))
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("interval")
+                        .then(RequiredArgumentBuilder.<CommandSource, Integer>argument("value", IntegerArgumentType.integer())
+                            .executes(c -> {
+                                CommandSource source = c.getSource();
+                                if (!(source instanceof IServerCommandSource)) throw CommandExceptions.multiplayerWorldOnly().create();
+
+                                MinecraftServer server = ((IServerCommandSource)source).getServer();
+
+                                int interval = c.getArgument("value", Integer.class);
+
+                                server.propertyManager.setProperty("autosaveInterval", interval);
+                                server.autoSaveInterval = interval;
+                                c.getSource().sendTranslatableMessage("command.commands.save.interval", interval);
+                                return Command.SINGLE_SUCCESS;
+                    })))
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("amount")
+                        .then(RequiredArgumentBuilder.<CommandSource, Integer>argument("value", IntegerArgumentType.integer())
+                            .executes(c -> {
+                                CommandSource source = c.getSource();
+                                if (!(source instanceof IServerCommandSource)) throw CommandExceptions.multiplayerWorldOnly().create();
+
+                                MinecraftServer server = ((IServerCommandSource)source).getServer();
+
+                                int amount = c.getArgument("value", Integer.class);
+
+                                server.propertyManager.setProperty("maxChunksSavedPerAutosave", amount);
+                                server.chunksSavedPerAutosave = amount;
+                                c.getSource().sendTranslatableMessage("command.commands.save.amount", amount);
+                                return Command.SINGLE_SUCCESS;
+                            })))
+
+            );
+    }
+}
diff --git a/src/main/java/net/minecraft/server/net/command/commands/UnbanCommand.java b/src/main/java/net/minecraft/server/net/command/commands/UnbanCommand.java
new file mode 100644
index 000000000..3fa77754f
--- /dev/null
+++ b/src/main/java/net/minecraft/server/net/command/commands/UnbanCommand.java
@@ -0,0 +1,59 @@
+package net.minecraft.server.net.command.commands;
+
+import com.mojang.brigadier.Command;
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.builder.RequiredArgumentBuilder;
+import com.mojang.brigadier.exceptions.DynamicCommandExceptionType;
+import net.minecraft.core.lang.I18n;
+import net.minecraft.core.net.command.CommandSource;
+import net.minecraft.core.net.command.exceptions.CommandExceptions;
+import net.minecraft.core.util.helper.UUIDHelper;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.net.command.IServerCommandSource;
+
+public class UnbanCommand {
+    private static final DynamicCommandExceptionType FAILURE =
+        new DynamicCommandExceptionType(arg -> () -> I18n.getInstance().translateKeyAndFormat("command.commands.unban.exception_failure", arg));
+
+    public static void register(CommandDispatcher<CommandSource> dispatcher) {
+        dispatcher.register
+            (
+                LiteralArgumentBuilder.<CommandSource>literal("unban")
+                    .requires(CommandSource::hasAdmin)
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("username")
+                        .then(RequiredArgumentBuilder.<CommandSource, String>argument("name", StringArgumentType.word()).executes(c -> {
+                            CommandSource source = c.getSource();
+                            if (!(source instanceof IServerCommandSource))
+                                throw CommandExceptions.multiplayerWorldOnly().create();
+
+                            MinecraftServer server = ((IServerCommandSource) source).getServer();
+
+                            String nameToUnban = c.getArgument("name", String.class);
+                            UUIDHelper.runConversionAction(nameToUnban, (uuid) -> {
+                                server.playerList.banPlayer(uuid);
+                                c.getSource().sendTranslatableMessage("command.commands.unban.username.success", nameToUnban);
+                            }, (username) -> {
+                                c.getSource().sendTranslatableMessage("command.commands.unban.username.fail.wrong_name", nameToUnban);
+                            });
+                            return Command.SINGLE_SUCCESS;
+                        })))
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("ip")
+                        .then(RequiredArgumentBuilder.<CommandSource, String>argument("address", StringArgumentType.word()).executes(c -> {
+                            CommandSource source = c.getSource();
+                            if (!(source instanceof IServerCommandSource))
+                                throw CommandExceptions.multiplayerWorldOnly().create();
+
+                            MinecraftServer server = ((IServerCommandSource) source).getServer();
+
+                            String ip = c.getArgument("address", String.class);
+                            server.playerList.pardonIP(ip);
+
+                            c.getSource().sendTranslatableMessage("command.commands.unban.ip.success", ip);
+                            return Command.SINGLE_SUCCESS;
+                        }))
+                    )
+            );
+    }
+}
diff --git a/src/main/java/net/minecraft/server/net/command/commands/WhitelistCommand.java b/src/main/java/net/minecraft/server/net/command/commands/WhitelistCommand.java
new file mode 100644
index 000000000..b6c9679f9
--- /dev/null
+++ b/src/main/java/net/minecraft/server/net/command/commands/WhitelistCommand.java
@@ -0,0 +1,123 @@
+package net.minecraft.server.net.command.commands;
+
+import com.mojang.brigadier.Command;
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.builder.RequiredArgumentBuilder;
+import com.mojang.brigadier.exceptions.DynamicCommandExceptionType;
+import net.minecraft.core.lang.I18n;
+import net.minecraft.core.net.command.CommandSource;
+import net.minecraft.core.net.command.exceptions.CommandExceptions;
+import net.minecraft.core.util.helper.UUIDHelper;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.entity.player.ServerPlayer;
+import net.minecraft.server.net.command.IServerCommandSource;
+
+import java.util.Set;
+import java.util.UUID;
+
+public class WhitelistCommand {
+    private static final DynamicCommandExceptionType FAILURE =
+        new DynamicCommandExceptionType(arg -> () -> I18n.getInstance().translateKeyAndFormat("command.commands.whitelist.exception_failure", arg));
+
+    public static void register(CommandDispatcher<CommandSource> dispatcher) {
+        dispatcher.register
+            (
+                LiteralArgumentBuilder.<CommandSource>literal("whitelist")
+                    .requires(CommandSource::hasAdmin)
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("on").executes(c -> {
+                        CommandSource source = c.getSource();
+                        if (!(source instanceof IServerCommandSource)) throw CommandExceptions.multiplayerWorldOnly().create();
+
+                        MinecraftServer server = ((IServerCommandSource)source).getServer();
+//                        sendNoticeToOps(senderName, "Turned on white-listing");
+                        c.getSource().sendTranslatableMessage("command.commands.whitelist.on.success");
+                        server.propertyManager.setProperty("white-list", true);
+                        server.playerList.whitelistEnforced = true;
+                        return Command.SINGLE_SUCCESS;
+                    }))
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("off").executes(c -> {
+                        CommandSource source = c.getSource();
+                        if (!(source instanceof IServerCommandSource)) throw CommandExceptions.multiplayerWorldOnly().create();
+
+                        MinecraftServer server = ((IServerCommandSource)source).getServer();
+//                        sendNoticeToOps(senderName, "Turned on white-listing");
+                        c.getSource().sendTranslatableMessage("command.commands.whitelist.off.success");
+                        server.propertyManager.setProperty("white-list", false);
+                        server.playerList.whitelistEnforced = false;
+                        return Command.SINGLE_SUCCESS;
+                    }))
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("list").executes(c -> {
+                        CommandSource source = c.getSource();
+                        if (!(source instanceof IServerCommandSource)) throw CommandExceptions.multiplayerWorldOnly().create();
+
+                        MinecraftServer server = ((IServerCommandSource)source).getServer();
+                        Set<UUID> set = server.playerList.getWhitelist();
+                        StringBuilder builder = new StringBuilder();
+                        for (UUID uuid : set) {
+                            builder.append("\"").append(uuid).append("\"").append(", ");
+                        }
+                        String message = builder.toString();
+                        if (message.endsWith(", ")){
+                            message = message.substring(0, message.length()-2);
+                        }
+                        c.getSource().sendTranslatableMessage("command.commands.whitelist.list", message);
+                        return Command.SINGLE_SUCCESS;
+                    }))
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("reload").executes(c -> {
+                        CommandSource source = c.getSource();
+                        if (!(source instanceof IServerCommandSource)) throw CommandExceptions.multiplayerWorldOnly().create();
+
+                        MinecraftServer server = ((IServerCommandSource)source).getServer();
+                        server.playerList.reloadWhiteList();
+                        c.getSource().sendTranslatableMessage("command.commands.whitelist.reload");
+                        return Command.SINGLE_SUCCESS;
+                    }))
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("add")
+                        .then(RequiredArgumentBuilder.<CommandSource, String>argument("name", StringArgumentType.word())
+                            .executes(c -> {
+                        CommandSource source = c.getSource();
+                        if (!(source instanceof IServerCommandSource)) throw CommandExceptions.multiplayerWorldOnly().create();
+
+                        MinecraftServer server = ((IServerCommandSource)source).getServer();
+
+                        String nameToAdd = c.getArgument("name", String.class);
+
+                        ServerPlayer player = server.playerList.getPlayerEntity(nameToAdd);
+                        if(player != null) {
+                            server.playerList.addToWhiteList(player.uuid);
+                            c.getSource().sendTranslatableMessage("command.commands.whitelist.add.success", player.username);
+                        } else {
+                            UUIDHelper.runConversionAction(nameToAdd, (uuid) -> {
+                                server.playerList.addToWhiteList(uuid);
+                                c.getSource().sendTranslatableMessage("command.commands.whitelist.add.success", nameToAdd);
+                            }, (username) -> c.getSource().sendTranslatableMessage("command.commands.whitelist.add.fail.wrong_name", username));
+                        }
+                        return Command.SINGLE_SUCCESS;
+                    })))
+                    .then(LiteralArgumentBuilder.<CommandSource>literal("remove")
+                        .then(RequiredArgumentBuilder.<CommandSource, String>argument("name", StringArgumentType.word())
+                            .executes(c -> {
+                                CommandSource source = c.getSource();
+                                if (!(source instanceof IServerCommandSource)) throw CommandExceptions.multiplayerWorldOnly().create();
+
+                                MinecraftServer server = ((IServerCommandSource)source).getServer();
+
+                                String nameToAdd = c.getArgument("name", String.class);
+
+                                ServerPlayer player = server.playerList.getPlayerEntity(nameToAdd);
+                                if(player != null) {
+                                    server.playerList.removeFromWhiteList(player.uuid);
+                                    c.getSource().sendTranslatableMessage("command.commands.whitelist.remove.success", player.username);
+                                } else {
+                                    UUIDHelper.runConversionAction(nameToAdd, (uuid) -> {
+                                        server.playerList.removeFromWhiteList(uuid);
+                                        c.getSource().sendTranslatableMessage("command.commands.whitelist.remove.success", nameToAdd);
+                                    }, (username) -> c.getSource().sendTranslatableMessage("command.commands.whitelist.remove.fail.wrong_name", username));
+                                }
+                                return Command.SINGLE_SUCCESS;
+                            })))
+            );
+    }
+}
diff --git a/src/main/java/net/minecraft/server/world/WorldServer.java b/src/main/java/net/minecraft/server/world/WorldServer.java
index 4a9ae8e22..bfdbf2b9b 100644
--- a/src/main/java/net/minecraft/server/world/WorldServer.java
+++ b/src/main/java/net/minecraft/server/world/WorldServer.java
@@ -263,7 +263,7 @@ public class WorldServer extends World
     }
     public ChunkProviderServer chunkProviderServer;
     public boolean field_819_z;
-    public boolean levelSaving;
+    public boolean dontSave;
     public MinecraftServer mcServer;
     private final IntHashMap<Entity> entityIntHashMap;
     private long lastWeatherSend = System.currentTimeMillis();
diff --git a/src/main/java/net/minecraft/server/world/chunk/provider/ChunkProviderServer.java b/src/main/java/net/minecraft/server/world/chunk/provider/ChunkProviderServer.java
index 831209fee..7abb9ff4f 100644
--- a/src/main/java/net/minecraft/server/world/chunk/provider/ChunkProviderServer.java
+++ b/src/main/java/net/minecraft/server/world/chunk/provider/ChunkProviderServer.java
@@ -241,7 +241,7 @@ public class ChunkProviderServer
     @Override
     public boolean tick()
     {
-        if(!world.levelSaving)
+        if(!world.dontSave)
         {
             for(int i = 0; i < 100; i++)
             {
@@ -273,7 +273,7 @@ public class ChunkProviderServer
     @Override
     public boolean canSave()
     {
-        return !world.levelSaving;
+        return !world.dontSave;
     }
     
     @Override
