MidnightControls 0.1.0 (Beta)

Changes from LambdaControls: - Support for Steam Deck and Dualsense - Support for L4, L5, R4, R5 buttons - Updated Libraries - New Logo and Name - Lots of Bugfixes - MidnightConfig backend
2025-12-14 07:35:10 +01:00 · 2022-03-12 22:33:19 +01:00
parent bfaa4f5d9a
commit 5fcf4c2b1b
113 changed files with 2934 additions and 3307 deletions
--- a/src/main/java/eu/midnightdust/midnightcontrols/client/controller/ButtonBinding.java
+++ b/src/main/java/eu/midnightdust/midnightcontrols/client/controller/ButtonBinding.java
@@ -0,0 +1,574 @@
+/*
+ * Copyright © 2021 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of midnightcontrols.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package eu.midnightdust.midnightcontrols.client.controller;
+
+import eu.midnightdust.midnightcontrols.client.ButtonState;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.option.GameOptions;
+import net.minecraft.client.option.KeyBinding;
+import net.minecraft.text.Text;
+import net.minecraft.text.TranslatableText;
+import net.minecraft.util.Identifier;
+import org.aperlambda.lambdacommon.utils.function.PairPredicate;
+import org.aperlambda.lambdacommon.utils.function.Predicates;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static org.lwjgl.glfw.GLFW.*;
+
+/**
+ * Represents a button binding.
+ *
+ * @author LambdAurora
+ * @version 1.7.0
+ * @since 1.0.0
+ */
+public class ButtonBinding {
+    public static final ButtonCategory MOVEMENT_CATEGORY;
+    public static final ButtonCategory GAMEPLAY_CATEGORY;
+    public static final ButtonCategory INVENTORY_CATEGORY;
+    public static final ButtonCategory MULTIPLAYER_CATEGORY;
+    public static final ButtonCategory MISC_CATEGORY;
+
+    public static final ButtonBinding ATTACK = new Builder("attack").buttons(axisAsButton(GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER, true)).onlyInGame().register();
+    public static final ButtonBinding BACK = new Builder("back").buttons(axisAsButton(GLFW_GAMEPAD_AXIS_LEFT_Y, false))
+            .action(MovementHandler.HANDLER).onlyInGame().register();
+    public static final ButtonBinding CHAT = new Builder("chat").buttons(GLFW_GAMEPAD_BUTTON_DPAD_RIGHT).onlyInGame().cooldown().register();
+    public static final ButtonBinding DROP_ITEM = new Builder("drop_item").buttons(GLFW_GAMEPAD_BUTTON_B).onlyInGame().cooldown().register();
+    public static final ButtonBinding FORWARD = new Builder("forward").buttons(axisAsButton(GLFW_GAMEPAD_AXIS_LEFT_Y, true))
+            .action(MovementHandler.HANDLER).onlyInGame().register();
+    public static final ButtonBinding HOTBAR_LEFT = new Builder("hotbar_left").buttons(GLFW_GAMEPAD_BUTTON_LEFT_BUMPER)
+            .action(InputHandlers.handleHotbar(false)).onlyInGame().cooldown().register();
+    public static final ButtonBinding HOTBAR_RIGHT = new Builder("hotbar_right").buttons(GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER)
+            .action(InputHandlers.handleHotbar(true)).onlyInGame().cooldown().register();
+    public static final ButtonBinding INVENTORY = new Builder("inventory").buttons(GLFW_GAMEPAD_BUTTON_Y).onlyInGame().cooldown().register();
+    public static final ButtonBinding JUMP = new Builder("jump").buttons(GLFW_GAMEPAD_BUTTON_A).onlyInGame().register();
+    public static final ButtonBinding LEFT = new Builder("left").buttons(axisAsButton(GLFW_GAMEPAD_AXIS_LEFT_X, false))
+            .action(MovementHandler.HANDLER).onlyInGame().register();
+    public static final ButtonBinding PAUSE_GAME = new Builder("pause_game").buttons(GLFW_GAMEPAD_BUTTON_START).action(InputHandlers::handlePauseGame).cooldown().register();
+    public static final ButtonBinding PICK_BLOCK = new Builder("pick_block").buttons(GLFW_GAMEPAD_BUTTON_DPAD_LEFT).onlyInGame().cooldown().register();
+    public static final ButtonBinding PLAYER_LIST = new Builder("player_list").buttons(GLFW_GAMEPAD_BUTTON_BACK).onlyInGame().register();
+    public static final ButtonBinding RIGHT = new Builder("right").buttons(axisAsButton(GLFW_GAMEPAD_AXIS_LEFT_X, true))
+            .action(MovementHandler.HANDLER).onlyInGame().register();
+    public static final ButtonBinding SCREENSHOT = new Builder("screenshot").buttons(GLFW_GAMEPAD_BUTTON_DPAD_UP, GLFW_GAMEPAD_BUTTON_A)
+            .action(InputHandlers::handleScreenshot).cooldown().register();
+    public static final ButtonBinding SLOT_DOWN = new Builder("slot_down").buttons(GLFW_GAMEPAD_BUTTON_DPAD_DOWN)
+            .action(InputHandlers.handleInventorySlotPad(1)).onlyInInventory().cooldown().register();
+    public static final ButtonBinding SLOT_LEFT = new Builder("slot_left").buttons(GLFW_GAMEPAD_BUTTON_DPAD_LEFT)
+            .action(InputHandlers.handleInventorySlotPad(3)).onlyInInventory().cooldown().register();
+    public static final ButtonBinding SLOT_RIGHT = new Builder("slot_right").buttons(GLFW_GAMEPAD_BUTTON_DPAD_RIGHT)
+            .action(InputHandlers.handleInventorySlotPad(2)).onlyInInventory().cooldown().register();
+    public static final ButtonBinding SLOT_UP = new Builder("slot_up").buttons(GLFW_GAMEPAD_BUTTON_DPAD_UP)
+            .action(InputHandlers.handleInventorySlotPad(0)).onlyInInventory().cooldown().register();
+    public static final ButtonBinding SMOOTH_CAMERA = new Builder("toggle_smooth_camera").onlyInGame().cooldown().register();
+    public static final ButtonBinding SNEAK = new Builder("sneak").buttons(GLFW_GAMEPAD_BUTTON_RIGHT_THUMB)
+            .actions(InputHandlers::handleToggleSneak).onlyInGame().cooldown().register();
+    public static final ButtonBinding SPRINT = new Builder("sprint").buttons(GLFW_GAMEPAD_BUTTON_LEFT_THUMB).onlyInGame().register();
+    public static final ButtonBinding SWAP_HANDS = new Builder("swap_hands").buttons(GLFW_GAMEPAD_BUTTON_X).onlyInGame().cooldown().register();
+    public static final ButtonBinding TAB_LEFT = new Builder("tab_back").buttons(GLFW_GAMEPAD_BUTTON_LEFT_BUMPER)
+            .action(InputHandlers.handleHotbar(false)).filter(Predicates.or(InputHandlers::inInventory, InputHandlers::inAdvancements)).cooldown().register();
+    public static final ButtonBinding TAB_RIGHT = new Builder("tab_next").buttons(GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER)
+            .action(InputHandlers.handleHotbar(true)).filter(Predicates.or(InputHandlers::inInventory, InputHandlers::inAdvancements)).cooldown().register();
+    public static final ButtonBinding TOGGLE_PERSPECTIVE = new Builder("toggle_perspective").buttons(GLFW_GAMEPAD_BUTTON_DPAD_UP, GLFW_GAMEPAD_BUTTON_Y).cooldown().register();
+    public static final ButtonBinding USE = new Builder("use").buttons(axisAsButton(GLFW_GAMEPAD_AXIS_LEFT_TRIGGER, true)).register();
+
+    private int[] button;
+    private final int[] defaultButton;
+    private final String key;
+    private final Text text;
+    private KeyBinding mcKeyBinding = null;
+    protected PairPredicate<MinecraftClient, ButtonBinding> filter;
+    private final List<PressAction> actions = new ArrayList<>(Collections.singletonList(PressAction.DEFAULT_ACTION));
+    private boolean hasCooldown;
+    private int cooldown = 0;
+    boolean pressed = false;
+
+    public ButtonBinding(String key, int[] defaultButton, List<PressAction> actions, PairPredicate<MinecraftClient, ButtonBinding> filter, boolean hasCooldown) {
+        this.setButton(this.defaultButton = defaultButton);
+        this.key = key;
+        this.text = new TranslatableText(this.key);
+        this.filter = filter;
+        this.actions.addAll(actions);
+        this.hasCooldown = hasCooldown;
+    }
+
+    public ButtonBinding(String key, int[] defaultButton, boolean hasCooldown) {
+        this(key, defaultButton, Collections.emptyList(), Predicates.pairAlwaysTrue(), hasCooldown);
+    }
+
+    /**
+     * Returns the button bound.
+     *
+     * @return the bound button
+     */
+    public int[] getButton() {
+        return this.button;
+    }
+
+    /**
+     * Sets the bound button.
+     *
+     * @param button the bound button
+     */
+    public void setButton(int[] button) {
+        this.button = button;
+
+        if (InputManager.hasBinding(this))
+            InputManager.sortBindings();
+    }
+
+    /**
+     * Returns whether the bound button is the specified button or not.
+     *
+     * @param button the button to check
+     * @return true if the bound button is the specified button, else false
+     */
+    public boolean isButton(int[] button) {
+        return InputManager.areButtonsEquivalent(button, this.button);
+    }
+
+    /**
+     * Returns whether this button is down or not.
+     *
+     * @return true if the button is down, else false
+     */
+    public boolean isButtonDown() {
+        return this.pressed;
+    }
+
+    /**
+     * Returns whether this button binding is bound or not.
+     *
+     * @return true if this button binding is bound, else false
+     */
+    public boolean isNotBound() {
+        return this.button.length == 0 || this.button[0] == -1;
+    }
+
+    /**
+     * Gets the default button assigned to this binding.
+     *
+     * @return the default button
+     */
+    public int[] getDefaultButton() {
+        return this.defaultButton;
+    }
+
+    /**
+     * Returns whether the assigned button is the default button.
+     *
+     * @return true if the assigned button is the default button, else false
+     */
+    public boolean isDefault() {
+        return this.button.length == this.defaultButton.length && InputManager.areButtonsEquivalent(this.button, this.defaultButton);
+    }
+
+    /**
+     * Returns the button code.
+     *
+     * @return the button code
+     */
+    public String getButtonCode() {
+        return Arrays.stream(this.button)
+                .mapToObj(btn -> Integer.valueOf(btn).toString())
+                .collect(Collectors.joining("+"));
+    }
+
+    /**
+     * Sets the key binding to emulate with this button binding.
+     *
+     * @param keyBinding the optional key binding
+     */
+    public void setKeyBinding(@Nullable KeyBinding keyBinding) {
+        this.mcKeyBinding = keyBinding;
+    }
+
+    /**
+     * Returns whether the button binding is available in the current context.
+     *
+     * @param client the client instance
+     * @return true if the button binding is available, else false
+     */
+    public boolean isAvailable(@NotNull MinecraftClient client) {
+        return this.filter.test(client, this);
+    }
+
+    /**
+     * Updates the button binding cooldown.
+     */
+    public void update() {
+        if (this.hasCooldown && this.cooldown > 0)
+            this.cooldown--;
+    }
+
+    /**
+     * Handles the button binding.
+     *
+     * @param client the client instance
+     * @param state the state
+     */
+    public void handle(@NotNull MinecraftClient client, float value, @NotNull ButtonState state) {
+        if (state == ButtonState.REPEAT && this.hasCooldown && this.cooldown != 0)
+            return;
+        if (this.hasCooldown && state.isPressed()) {
+            this.cooldown = 5;
+        }
+        for (int i = this.actions.size() - 1; i >= 0; i--) {
+            if (this.actions.get(i).press(client, this, value, state))
+                break;
+        }
+    }
+
+    public @NotNull String getName() {
+        return this.key;
+    }
+
+    /**
+     * Returns the translation key of this button binding.
+     *
+     * @return the translation key
+     */
+    public @NotNull String getTranslationKey() {
+        return "midnightcontrols.action." + this.getName();
+    }
+
+    public @NotNull Text getText() {
+        return this.text;
+    }
+
+    /**
+     * Returns the key binding equivalent of this button binding.
+     *
+     * @return the key binding equivalent
+     */
+    public @NotNull Optional<KeyBinding> asKeyBinding() {
+        return Optional.ofNullable(this.mcKeyBinding);
+    }
+
+    @Override
+    public String toString() {
+        return "ButtonBinding{id=\"" + this.key + "\","
+                + "hasCooldown=" + this.hasCooldown
+                + "}";
+    }
+
+    /**
+     * Returns the specified axis as a button.
+     *
+     * @param axis the axis
+     * @param positive true if the axis part is positive, else false
+     * @return the axis as a button
+     */
+    public static int axisAsButton(int axis, boolean positive) {
+        return positive ? 100 + axis : 200 + axis;
+    }
+
+    /**
+     * Returns whether the specified button is an axis or not.
+     *
+     * @param button the button
+     * @return true if the button is an axis, else false
+     */
+    public static boolean isAxis(int button) {
+        button %= 500;
+        return button >= 100;
+    }
+
+    /**
+     * Returns the second Joycon's specified button code.
+     *
+     * @param button the raw button code
+     * @return the second Joycon's button code
+     */
+    public static int controller2Button(int button) {
+        return 500 + button;
+    }
+
+    public static void init(@NotNull GameOptions options) {
+        ATTACK.mcKeyBinding = options.keyAttack;
+        BACK.mcKeyBinding = options.keyBack;
+        CHAT.mcKeyBinding = options.keyChat;
+        DROP_ITEM.mcKeyBinding = options.keyDrop;
+        FORWARD.mcKeyBinding = options.keyForward;
+        INVENTORY.mcKeyBinding = options.keyInventory;
+        JUMP.mcKeyBinding = options.keyJump;
+        LEFT.mcKeyBinding = options.keyLeft;
+        PICK_BLOCK.mcKeyBinding = options.keyPickItem;
+        PLAYER_LIST.mcKeyBinding = options.keyPlayerList;
+        RIGHT.mcKeyBinding = options.keyRight;
+        SCREENSHOT.mcKeyBinding = options.keyScreenshot;
+        SMOOTH_CAMERA.mcKeyBinding = options.keySmoothCamera;
+        SNEAK.mcKeyBinding = options.keySneak;
+        SPRINT.mcKeyBinding = options.keySprint;
+        SWAP_HANDS.mcKeyBinding = options.keySwapHands;
+        TOGGLE_PERSPECTIVE.mcKeyBinding = options.keyTogglePerspective;
+        USE.mcKeyBinding = options.keyUse;
+    }
+
+    /**
+     * Returns the localized name of the specified button.
+     *
+     * @param button the button
+     * @return the localized name of the button
+     */
+    public static @NotNull Text getLocalizedButtonName(int button) {
+        return switch (button % 500) {
+            case -1 -> new TranslatableText("key.keyboard.unknown");
+            case GLFW_GAMEPAD_BUTTON_A -> new TranslatableText("midnightcontrols.button.a");
+            case GLFW_GAMEPAD_BUTTON_B -> new TranslatableText("midnightcontrols.button.b");
+            case GLFW_GAMEPAD_BUTTON_X -> new TranslatableText("midnightcontrols.button.x");
+            case GLFW_GAMEPAD_BUTTON_Y -> new TranslatableText("midnightcontrols.button.y");
+            case GLFW_GAMEPAD_BUTTON_LEFT_BUMPER -> new TranslatableText("midnightcontrols.button.left_bumper");
+            case GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER -> new TranslatableText("midnightcontrols.button.right_bumper");
+            case GLFW_GAMEPAD_BUTTON_BACK -> new TranslatableText("midnightcontrols.button.back");
+            case GLFW_GAMEPAD_BUTTON_START -> new TranslatableText("midnightcontrols.button.start");
+            case GLFW_GAMEPAD_BUTTON_GUIDE -> new TranslatableText("midnightcontrols.button.guide");
+            case GLFW_GAMEPAD_BUTTON_LEFT_THUMB -> new TranslatableText("midnightcontrols.button.left_thumb");
+            case GLFW_GAMEPAD_BUTTON_RIGHT_THUMB -> new TranslatableText("midnightcontrols.button.right_thumb");
+            case GLFW_GAMEPAD_BUTTON_DPAD_UP -> new TranslatableText("midnightcontrols.button.dpad_up");
+            case GLFW_GAMEPAD_BUTTON_DPAD_RIGHT -> new TranslatableText("midnightcontrols.button.dpad_right");
+            case GLFW_GAMEPAD_BUTTON_DPAD_DOWN -> new TranslatableText("midnightcontrols.button.dpad_down");
+            case GLFW_GAMEPAD_BUTTON_DPAD_LEFT -> new TranslatableText("midnightcontrols.button.dpad_left");
+            case 100 -> new TranslatableText("midnightcontrols.axis.left_x+");
+            case 101 -> new TranslatableText("midnightcontrols.axis.left_y+");
+            case 102 -> new TranslatableText("midnightcontrols.axis.right_x+");
+            case 103 -> new TranslatableText("midnightcontrols.axis.right_y+");
+            case 104 -> new TranslatableText("midnightcontrols.axis.left_trigger");
+            case 105 -> new TranslatableText("midnightcontrols.axis.right_trigger");
+            case 200 -> new TranslatableText("midnightcontrols.axis.left_x-");
+            case 201 -> new TranslatableText("midnightcontrols.axis.left_y-");
+            case 202 -> new TranslatableText("midnightcontrols.axis.right_x-");
+            case 203 -> new TranslatableText("midnightcontrols.axis.right_y-");
+            case 15 -> new TranslatableText("midnightcontrols.button.l4");
+            case 16 -> new TranslatableText("midnightcontrols.button.l5");
+            case 17 -> new TranslatableText("midnightcontrols.button.r4");
+            case 18 -> new TranslatableText("midnightcontrols.button.r5");
+            default -> new TranslatableText("midnightcontrols.button.unknown", button);
+        };
+    }
+
+    static {
+        MOVEMENT_CATEGORY = InputManager.registerDefaultCategory("key.categories.movement", category -> category.registerAllBindings(
+                ButtonBinding.FORWARD,
+                ButtonBinding.BACK,
+                ButtonBinding.LEFT,
+                ButtonBinding.RIGHT,
+                ButtonBinding.JUMP,
+                ButtonBinding.SNEAK,
+                ButtonBinding.SPRINT));
+        GAMEPLAY_CATEGORY = InputManager.registerDefaultCategory("key.categories.gameplay", category -> category.registerAllBindings(
+                ButtonBinding.ATTACK,
+                ButtonBinding.PICK_BLOCK,
+                ButtonBinding.USE
+        ));
+        INVENTORY_CATEGORY = InputManager.registerDefaultCategory("key.categories.inventory", category -> category.registerAllBindings(
+                ButtonBinding.DROP_ITEM,
+                ButtonBinding.HOTBAR_LEFT,
+                ButtonBinding.HOTBAR_RIGHT,
+                ButtonBinding.INVENTORY,
+                ButtonBinding.SWAP_HANDS
+        ));
+        MULTIPLAYER_CATEGORY = InputManager.registerDefaultCategory("key.categories.multiplayer",
+                category -> category.registerAllBindings(ButtonBinding.CHAT, ButtonBinding.PLAYER_LIST));
+        MISC_CATEGORY = InputManager.registerDefaultCategory("key.categories.misc", category -> category.registerAllBindings(
+                ButtonBinding.SCREENSHOT,
+                //SMOOTH_CAMERA,
+                ButtonBinding.TOGGLE_PERSPECTIVE
+        ));
+    }
+
+    /**
+     * Returns a builder instance.
+     *
+     * @param identifier the identifier of the button binding
+     * @return the builder instance
+     * @since 1.5.0
+     */
+    public static Builder builder(@NotNull Identifier identifier) {
+        return new Builder(identifier);
+
+    }
+
+    /**
+     * Represents a quick {@link ButtonBinding} builder.
+     *
+     * @author LambdAurora
+     * @version 1.5.0
+     * @since 1.1.0
+     */
+    public static class Builder {
+        private final String key;
+        private int[] buttons = new int[0];
+        private final List<PressAction> actions = new ArrayList<>();
+        private PairPredicate<MinecraftClient, ButtonBinding> filter = Predicates.pairAlwaysTrue();
+        private boolean cooldown = false;
+        private ButtonCategory category = null;
+        private KeyBinding mcBinding = null;
+
+        /**
+         * This constructor shouldn't be used for other mods.
+         *
+         * @param key the key with format {@code "<namespace>.<name>"}
+         */
+        public Builder(@NotNull String key) {
+            this.key = key;
+            this.unbound();
+        }
+
+        public Builder(@NotNull Identifier identifier) {
+            this(identifier.getNamespace() + "." + identifier.getNamespace());
+        }
+
+        /**
+         * Defines the default buttons of the {@link ButtonBinding}.
+         *
+         * @param buttons the default buttons
+         * @return the builder instance
+         */
+        public Builder buttons(int... buttons) {
+            this.buttons = buttons;
+            return this;
+        }
+
+        /**
+         * Sets the {@link ButtonBinding} to unbound.
+         *
+         * @return the builder instance
+         */
+        public Builder unbound() {
+            return this.buttons(-1);
+        }
+
+        /**
+         * Adds the actions to the {@link ButtonBinding}.
+         *
+         * @param actions the actions to add
+         * @return the builder instance
+         */
+        public Builder actions(@NotNull PressAction... actions) {
+            this.actions.addAll(Arrays.asList(actions));
+            return this;
+        }
+
+        /**
+         * Adds an action to the {@link ButtonBinding}.
+         *
+         * @param action the action to add
+         * @return the builder instance
+         */
+        public Builder action(@NotNull PressAction action) {
+            this.actions.add(action);
+            return this;
+        }
+
+        /**
+         * Sets a filter for the {@link ButtonBinding}.
+         *
+         * @param filter the filter
+         * @return the builder instance
+         */
+        public Builder filter(@NotNull PairPredicate<MinecraftClient, ButtonBinding> filter) {
+            this.filter = filter;
+            return this;
+        }
+
+        /**
+         * Sets the filter of {@link ButtonBinding} to only in game.
+         *
+         * @return the builder instance
+         * @see #filter(PairPredicate)
+         * @see InputHandlers#inGame(MinecraftClient, ButtonBinding)
+         */
+        public Builder onlyInGame() {
+            return this.filter(InputHandlers::inGame);
+        }
+
+        /**
+         * Sets the filter of {@link ButtonBinding} to only in inventory.
+         *
+         * @return the builder instance
+         * @see #filter(PairPredicate)
+         * @see InputHandlers#inInventory(MinecraftClient, ButtonBinding)
+         */
+        public Builder onlyInInventory() {
+            return this.filter(InputHandlers::inInventory);
+        }
+
+        /**
+         * Sets whether the {@link ButtonBinding} has a cooldown or not.
+         *
+         * @param cooldown true if the {@link ButtonBinding} has a cooldown, else false
+         * @return the builder instance
+         */
+        public Builder cooldown(boolean cooldown) {
+            this.cooldown = cooldown;
+            return this;
+        }
+
+        /**
+         * Puts a cooldown on the {@link ButtonBinding}.
+         *
+         * @return the builder instance
+         * @since 1.5.0
+         */
+        public Builder cooldown() {
+            return this.cooldown(true);
+        }
+
+        /**
+         * Sets the category of the {@link ButtonBinding}.
+         *
+         * @param category the category
+         * @return the builder instance
+         */
+        public Builder category(@Nullable ButtonCategory category) {
+            this.category = category;
+            return this;
+        }
+
+        /**
+         * Sets the keybinding linked to the {@link ButtonBinding}.
+         *
+         * @param binding the keybinding to link
+         * @return the builder instance
+         */
+        public Builder linkKeybind(@Nullable KeyBinding binding) {
+            this.mcBinding = binding;
+            return this;
+        }
+
+        /**
+         * Builds the {@link ButtonBinding}.
+         *
+         * @return the built {@link ButtonBinding}
+         */
+        public ButtonBinding build() {
+            var binding = new ButtonBinding(this.key, this.buttons, this.actions, this.filter, this.cooldown);
+            if (this.category != null)
+                this.category.registerBinding(binding);
+            if (this.mcBinding != null)
+                binding.setKeyBinding(this.mcBinding);
+            return binding;
+        }
+
+        /**
+         * Builds and registers the {@link ButtonBinding}.
+         *
+         * @return the built {@link ButtonBinding}
+         * @see #build()
+         */
+        public ButtonBinding register() {
+            return InputManager.registerBinding(this.build());
+        }
+    }
+}
--- a/src/main/java/eu/midnightdust/midnightcontrols/client/controller/ButtonCategory.java
+++ b/src/main/java/eu/midnightdust/midnightcontrols/client/controller/ButtonCategory.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright © 2021 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of midnightcontrols.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package eu.midnightdust.midnightcontrols.client.controller;
+
+import net.minecraft.client.resource.language.I18n;
+import org.aperlambda.lambdacommon.Identifier;
+import org.aperlambda.lambdacommon.utils.Identifiable;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Represents a button binding category
+ *
+ * @author LambdAurora
+ * @version 1.1.0
+ * @since 1.1.0
+ */
+public class ButtonCategory implements Identifiable {
+    private final List<ButtonBinding> bindings = new ArrayList<>();
+    private final Identifier id;
+    private final int priority;
+
+    public ButtonCategory(@NotNull Identifier id, int priority) {
+        this.id = id;
+        this.priority = priority;
+    }
+
+    public ButtonCategory(@NotNull Identifier id) {
+        this(id, 100);
+    }
+
+    public void registerBinding(@NotNull ButtonBinding binding) {
+        if (this.bindings.contains(binding))
+            throw new IllegalStateException("Cannot register twice a button binding in the same category.");
+        this.bindings.add(binding);
+    }
+
+    public void registerAllBindings(@NotNull ButtonBinding... bindings) {
+        this.registerAllBindings(Arrays.asList(bindings));
+    }
+
+    public void registerAllBindings(@NotNull List<ButtonBinding> bindings) {
+        bindings.forEach(this::registerBinding);
+    }
+
+    /**
+     * Gets the bindings assigned to this category.
+     *
+     * @return the bindings assigned to this category
+     */
+    public @NotNull List<ButtonBinding> getBindings() {
+        return Collections.unmodifiableList(this.bindings);
+    }
+
+    /**
+     * Gets the translated name of this category.
+     * <p>
+     * The translation key should be `modid.identifier_name`.
+     *
+     * @return the translated name
+     */
+    public @NotNull String getTranslatedName() {
+        if (this.id.getNamespace().equals("minecraft"))
+            return I18n.translate(this.id.getName());
+        else
+            return I18n.translate(this.id.getNamespace() + "." + this.id.getName());
+    }
+
+    /**
+     * Gets the priority display of this category.
+     * It will defines in which order the categories will display on the controls screen.
+     *
+     * @return the priority of this category
+     */
+    public int getPriority() {
+        return this.priority;
+    }
+
+    @Override
+    public @NotNull Identifier getIdentifier() {
+        return this.id;
+    }
+}
--- a/src/main/java/eu/midnightdust/midnightcontrols/client/controller/Controller.java
+++ b/src/main/java/eu/midnightdust/midnightcontrols/client/controller/Controller.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright © 2021 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of midnightcontrols.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package eu.midnightdust.midnightcontrols.client.controller;
+
+import eu.midnightdust.midnightcontrols.MidnightControls;
+import eu.midnightdust.midnightcontrols.client.MidnightControlsClient;
+import eu.midnightdust.midnightcontrols.client.MidnightControlsConfig;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.toast.SystemToast;
+import net.minecraft.text.LiteralText;
+import net.minecraft.text.TranslatableText;
+import org.aperlambda.lambdacommon.utils.Nameable;
+import org.jetbrains.annotations.NotNull;
+import org.lwjgl.glfw.GLFW;
+import org.lwjgl.glfw.GLFWGamepadState;
+import org.lwjgl.system.MemoryStack;
+import org.lwjgl.system.MemoryUtil;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import static org.lwjgl.BufferUtils.createByteBuffer;
+
+/**
+ * Represents a controller.
+ *
+ * @author LambdAurora
+ * @version 1.7.0
+ * @since 1.0.0
+ */
+public record Controller(int id) implements Nameable {
+    private static final Map<Integer, Controller> CONTROLLERS = new HashMap<>();
+
+    /**
+     * Gets the controller's globally unique identifier.
+     *
+     * @return the controller's GUID
+     */
+    public String getGuid() {
+        String guid = GLFW.glfwGetJoystickGUID(this.id);
+        return guid == null ? "" : guid;
+    }
+
+    /**
+     * Returns whether this controller is connected or not.
+     *
+     * @return true if this controller is connected, else false
+     */
+    public boolean isConnected() {
+        return GLFW.glfwJoystickPresent(this.id);
+    }
+
+    /**
+     * Returns whether this controller is a gamepad or not.
+     *
+     * @return true if this controller is a gamepad, else false
+     */
+    public boolean isGamepad() {
+        return this.isConnected() && GLFW.glfwJoystickIsGamepad(this.id);
+    }
+
+    /**
+     * Gets the name of the controller.
+     *
+     * @return the controller's name
+     */
+    @Override
+    public String getName() {
+        var name = this.isGamepad() ? GLFW.glfwGetGamepadName(this.id) : GLFW.glfwGetJoystickName(this.id);
+        return name == null ? String.valueOf(this.id()) : name;
+    }
+
+    /**
+     * Gets the state of the controller.
+     *
+     * @return the state of the controller input
+     */
+    public GLFWGamepadState getState() {
+        var state = GLFWGamepadState.create();
+        if (this.isGamepad())
+            GLFW.glfwGetGamepadState(this.id, state);
+        return state;
+    }
+
+    public static Controller byId(int id) {
+        if (id > GLFW.GLFW_JOYSTICK_LAST) {
+            MidnightControlsClient.get().log("Controller '" + id + "' doesn't exist.");
+            id = GLFW.GLFW_JOYSTICK_LAST;
+        }
+        Controller controller;
+        if (CONTROLLERS.containsKey(id))
+            return CONTROLLERS.get(id);
+        else {
+            controller = new Controller(id);
+            CONTROLLERS.put(id, controller);
+            return controller;
+        }
+    }
+
+    public static Optional<Controller> byGuid(@NotNull String guid) {
+        return CONTROLLERS.values().stream().filter(Controller::isConnected)
+                .filter(controller -> controller.getGuid().equals(guid))
+                .max(Comparator.comparingInt(Controller::id));
+    }
+
+    /**
+     * Reads the specified resource and returns the raw data as a ByteBuffer.
+     *
+     * @param resource the resource to read
+     * @param bufferSize the initial buffer size
+     * @return the resource data
+     * @throws IOException If an IO error occurs.
+     */
+    private static ByteBuffer ioResourceToBuffer(String resource, int bufferSize) throws IOException {
+        ByteBuffer buffer = null;
+
+        var path = Paths.get(resource);
+        if (Files.isReadable(path)) {
+            try (var fc = Files.newByteChannel(path)) {
+                buffer = createByteBuffer((int) fc.size() + 2);
+                while (fc.read(buffer) != -1) ;
+                buffer.put((byte) 0);
+            }
+        }
+
+        buffer.flip(); // Force Java 8 >.<
+        return buffer;
+    }
+
+    /**
+     * Updates the controller mappings.
+     */
+    public static void updateMappings() {
+        try {
+            if (!MidnightControlsClient.MAPPINGS_FILE.exists())
+                return;
+            MidnightControlsClient.get().log("Updating controller mappings...");
+            var buffer = ioResourceToBuffer(MidnightControlsClient.MAPPINGS_FILE.getPath(), 1024);
+            GLFW.glfwUpdateGamepadMappings(buffer);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        try (var memoryStack = MemoryStack.stackPush()) {
+            var pointerBuffer = memoryStack.mallocPointer(1);
+            int i = GLFW.glfwGetError(pointerBuffer);
+            if (i != 0) {
+                long l = pointerBuffer.get();
+                var string = l == 0L ? "" : MemoryUtil.memUTF8(l);
+                var client = MinecraftClient.getInstance();
+                if (client != null) {
+                    client.getToastManager().add(SystemToast.create(client, SystemToast.Type.TUTORIAL_HINT,
+                            new TranslatableText("midnightcontrols.controller.mappings.error"), new LiteralText(string)));
+                }
+            }
+        } catch (Throwable e) {
+            /* Ignored :concern: */
+        }
+
+        if (MidnightControlsConfig.debug) {
+            for (int i = GLFW.GLFW_JOYSTICK_1; i <= GLFW.GLFW_JOYSTICK_16; i++) {
+                var controller = byId(i);
+
+                if (!controller.isConnected())
+                    continue;
+
+                MidnightControls.get().log(String.format("Controller #%d name: \"%s\"\n GUID: %s\n Gamepad: %s",
+                        controller.id,
+                        controller.getName(),
+                        controller.getGuid(),
+                        controller.isGamepad()));
+            }
+        }
+    }
+}
--- a/src/main/java/eu/midnightdust/midnightcontrols/client/controller/InputHandlers.java
+++ b/src/main/java/eu/midnightdust/midnightcontrols/client/controller/InputHandlers.java
@@ -0,0 +1,267 @@
+/*
+ * Copyright © 2021 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of midnightcontrols.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package eu.midnightdust.midnightcontrols.client.controller;
+
+import eu.midnightdust.midnightcontrols.client.ButtonState;
+import eu.midnightdust.midnightcontrols.client.MidnightInput;
+import eu.midnightdust.midnightcontrols.client.mixin.AdvancementsScreenAccessor;
+import eu.midnightdust.midnightcontrols.client.mixin.CreativeInventoryScreenAccessor;
+import eu.midnightdust.midnightcontrols.client.mixin.RecipeBookWidgetAccessor;
+import eu.midnightdust.midnightcontrols.client.util.HandledScreenAccessor;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gl.Framebuffer;
+import net.minecraft.client.gui.screen.advancement.AdvancementsScreen;
+import net.minecraft.client.gui.screen.ingame.HandledScreen;
+import net.minecraft.client.gui.screen.ingame.InventoryScreen;
+import net.minecraft.client.util.ScreenshotRecorder;
+import net.minecraft.item.ItemGroup;
+import net.minecraft.screen.slot.Slot;
+import org.aperlambda.lambdacommon.utils.Pair;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Comparator;
+import java.util.Optional;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+/**
+ * Represents some input handlers.
+ *
+ * @author LambdAurora
+ * @version 1.7.0
+ * @since 1.1.0
+ */
+public class InputHandlers {
+    private InputHandlers() {
+    }
+
+    public static PressAction handleHotbar(boolean next) {
+        return (client, button, value, action) -> {
+            if (action == ButtonState.RELEASE)
+                return false;
+
+            // When ingame
+            if (client.currentScreen == null && client.player != null) {
+                if (next)
+                    client.player.getInventory().selectedSlot = client.player.getInventory().selectedSlot == 8 ? 0 : client.player.getInventory().selectedSlot + 1;
+                else
+                    client.player.getInventory().selectedSlot = client.player.getInventory().selectedSlot == 0 ? 8 : client.player.getInventory().selectedSlot - 1;
+                return true;
+            } else if (client.currentScreen instanceof CreativeInventoryScreenAccessor inventory) {
+                int currentTab = inventory.getSelectedTab();
+                int nextTab = currentTab + (next ? 1 : -1);
+                if (nextTab < 0)
+                    nextTab = ItemGroup.GROUPS.length - 1;
+                else if (nextTab >= ItemGroup.GROUPS.length)
+                    nextTab = 0;
+                inventory.midnightcontrols$setSelectedTab(ItemGroup.GROUPS[nextTab]);
+                return true;
+            } else if (client.currentScreen instanceof InventoryScreen inventoryScreen) {
+                var recipeBook = (RecipeBookWidgetAccessor) inventoryScreen.getRecipeBookWidget();
+                var tabs = recipeBook.getTabButtons();
+                var currentTab = recipeBook.getCurrentTab();
+                if (currentTab == null)
+                    return false;
+                int nextTab = tabs.indexOf(currentTab) + (next ? 1 : -1);
+                if (nextTab < 0)
+                    nextTab = tabs.size() - 1;
+                else if (nextTab >= tabs.size())
+                    nextTab = 0;
+                currentTab.setToggled(false);
+                recipeBook.setCurrentTab(currentTab = tabs.get(nextTab));
+                currentTab.setToggled(true);
+                recipeBook.midnightcontrols$refreshResults(true);
+                return true;
+            } else if (client.currentScreen instanceof AdvancementsScreenAccessor screen) {
+                var tabs = screen.getTabs().values().stream().distinct().collect(Collectors.toList());
+                var tab = screen.getSelectedTab();
+                if (tab == null)
+                    return false;
+                for (int i = 0; i < tabs.size(); i++) {
+                    if (tabs.get(i).equals(tab)) {
+                        int nextTab = i + (next ? 1 : -1);
+                        if (nextTab < 0)
+                            nextTab = tabs.size() - 1;
+                        else if (nextTab >= tabs.size())
+                            nextTab = 0;
+                        screen.getAdvancementManager().selectTab(tabs.get(nextTab).getRoot(), true);
+                        break;
+                    }
+                }
+                return true;
+            }
+            return false;
+        };
+    }
+
+    public static boolean handlePauseGame(@NotNull MinecraftClient client, @NotNull ButtonBinding binding, float value, @NotNull ButtonState action) {
+        if (action == ButtonState.PRESS) {
+            // If in game, then pause the game.
+            if (client.currentScreen == null)
+                client.openPauseMenu(false);
+            else if (client.currentScreen instanceof HandledScreen && client.player != null) // If the current screen is a container then close it.
+                client.player.closeHandledScreen();
+            else // Else just close the current screen.
+                client.currentScreen.onClose();
+        }
+        return true;
+    }
+
+    /**
+     * Handles the screenshot action.
+     *
+     * @param client the client instance
+     * @param binding the binding which fired the action
+     * @param action the action done on the binding
+     * @return true if handled, else false
+     */
+    public static boolean handleScreenshot(@NotNull MinecraftClient client, @NotNull ButtonBinding binding, float value, @NotNull ButtonState action) {
+        if (action == ButtonState.RELEASE)
+            ScreenshotRecorder.saveScreenshot(client.runDirectory, client.getFramebuffer(),
+                    text -> client.execute(() -> client.inGameHud.getChatHud().addMessage(text)));
+        return true;
+    }
+
+    public static boolean handleToggleSneak(@NotNull MinecraftClient client, @NotNull ButtonBinding button, float value, @NotNull ButtonState action) {
+        button.asKeyBinding().ifPresent(binding -> {
+            boolean sneakToggled = client.options.sneakToggled;
+            if (client.player.getAbilities().flying && sneakToggled)
+                client.options.sneakToggled = false;
+            binding.setPressed(button.pressed);
+            if (client.player.getAbilities().flying && sneakToggled)
+                client.options.sneakToggled = true;
+        });
+        return true;
+    }
+
+    public static PressAction handleInventorySlotPad(int direction) {
+        return (client, binding, value, action) -> {
+            if (!(client.currentScreen instanceof HandledScreen inventory && action != ButtonState.RELEASE))
+                return false;
+
+            var accessor = (HandledScreenAccessor) inventory;
+            int guiLeft = accessor.getX();
+            int guiTop = accessor.getY();
+            double mouseX = client.mouse.getX() * (double) client.getWindow().getScaledWidth() / (double) client.getWindow().getWidth();
+            double mouseY = client.mouse.getY() * (double) client.getWindow().getScaledHeight() / (double) client.getWindow().getHeight();
+
+            // Finds the hovered slot.
+            var mouseSlot = accessor.midnightcontrols$getSlotAt(mouseX, mouseY);
+
+            // Finds the closest slot in the GUI within 14 pixels.
+            Optional<Slot> closestSlot = inventory.getScreenHandler().slots.parallelStream()
+                    .filter(Predicate.isEqual(mouseSlot).negate())
+                    .map(slot -> {
+                        int posX = guiLeft + slot.x + 8;
+                        int posY = guiTop + slot.y + 8;
+
+                        int otherPosX = (int) mouseX;
+                        int otherPosY = (int) mouseY;
+                        if (mouseSlot != null) {
+                            otherPosX = guiLeft + mouseSlot.x + 8;
+                            otherPosY = guiTop + mouseSlot.y + 8;
+                        }
+
+                        // Distance between the slot and the cursor.
+                        double distance = Math.sqrt(Math.pow(posX - otherPosX, 2) + Math.pow(posY - otherPosY, 2));
+                        return Pair.of(slot, distance);
+                    }).filter(entry -> {
+                        var slot = entry.key;
+                        int posX = guiLeft + slot.x + 8;
+                        int posY = guiTop + slot.y + 8;
+                        int otherPosX = (int) mouseX;
+                        int otherPosY = (int) mouseY;
+                        if (mouseSlot != null) {
+                            otherPosX = guiLeft + mouseSlot.x + 8;
+                            otherPosY = guiTop + mouseSlot.y + 8;
+                        }
+                        if (direction == 0)
+                            return posY < otherPosY;
+                        else if (direction == 1)
+                            return posY > otherPosY;
+                        else if (direction == 2)
+                            return posX > otherPosX;
+                        else if (direction == 3)
+                            return posX < otherPosX;
+                        else
+                            return false;
+                    })
+                    .min(Comparator.comparingDouble(p -> p.value))
+                    .map(p -> p.key);
+
+            if (closestSlot.isPresent()) {
+                var slot = closestSlot.get();
+                int x = guiLeft + slot.x + 8;
+                int y = guiTop + slot.y + 8;
+                InputManager.queueMousePosition(x * (double) client.getWindow().getWidth() / (double) client.getWindow().getScaledWidth(),
+                        y * (double) client.getWindow().getHeight() / (double) client.getWindow().getScaledHeight());
+                return true;
+            }
+            return false;
+        };
+    }
+
+    /**
+     * Returns always true to the filter.
+     *
+     * @param client the client instance
+     * @param binding the affected binding
+     * @return true
+     */
+    public static boolean always(@NotNull MinecraftClient client, @NotNull ButtonBinding binding) {
+        return true;
+    }
+
+    /**
+     * Returns whether the client is in game or not.
+     *
+     * @param client the client instance
+     * @param binding the affected binding
+     * @return true if the client is in game, else false
+     */
+    public static boolean inGame(@NotNull MinecraftClient client, @NotNull ButtonBinding binding) {
+        return client.currentScreen == null;
+    }
+
+    /**
+     * Returns whether the client is in a non-interactive screen (which means require mouse input) or not.
+     *
+     * @param client the client instance
+     * @param binding the affected binding
+     * @return true if the client is in a non-interactive screen, else false
+     */
+    public static boolean inNonInteractiveScreens(@NotNull MinecraftClient client, @NotNull ButtonBinding binding) {
+        if (client.currentScreen == null)
+            return false;
+        return !MidnightInput.isScreenInteractive(client.currentScreen);
+    }
+
+    /**
+     * Returns whether the client is in an inventory or not.
+     *
+     * @param client the client instance
+     * @param binding the affected binding
+     * @return true if the client is in an inventory, else false
+     */
+    public static boolean inInventory(@NotNull MinecraftClient client, @NotNull ButtonBinding binding) {
+        return client.currentScreen instanceof HandledScreen;
+    }
+
+    /**
+     * Returns whether the client is in the advancements screen or not.
+     *
+     * @param client the client instance
+     * @param binding the affected binding
+     * @return true if the client is in the advancements screen, else false
+     */
+    public static boolean inAdvancements(@NotNull MinecraftClient client, @NotNull ButtonBinding binding) {
+        return client.currentScreen instanceof AdvancementsScreen;
+    }
+}
--- a/src/main/java/eu/midnightdust/midnightcontrols/client/controller/InputManager.java
+++ b/src/main/java/eu/midnightdust/midnightcontrols/client/controller/InputManager.java
@@ -0,0 +1,385 @@
+/*
+ * Copyright © 2021 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of midnightcontrols.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package eu.midnightdust.midnightcontrols.client.controller;
+
+import eu.midnightdust.midnightcontrols.ControlsMode;
+import eu.midnightdust.midnightcontrols.client.ButtonState;
+import eu.midnightdust.midnightcontrols.client.MidnightControlsConfig;
+import eu.midnightdust.midnightcontrols.client.util.MouseAccessor;
+import it.unimi.dsi.fastutil.ints.*;
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.option.KeyBinding;
+import net.minecraft.client.util.InputUtil;
+import net.minecraft.util.math.MathHelper;
+import org.aperlambda.lambdacommon.Identifier;
+import org.aperlambda.lambdacommon.utils.function.PairPredicate;
+import org.jetbrains.annotations.NotNull;
+import org.lwjgl.glfw.GLFW;
+
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Represents an input manager for controllers.
+ *
+ * @author LambdAurora
+ * @version 1.7.0
+ * @since 1.1.0
+ */
+public class InputManager {
+    public static final InputManager INPUT_MANAGER = new InputManager();
+    private static final List<ButtonBinding> BINDINGS = new ArrayList<>();
+    private static final List<ButtonCategory> CATEGORIES = new ArrayList<>();
+    public static final Int2ObjectMap<ButtonState> STATES = new Int2ObjectOpenHashMap<>();
+    public static final Int2FloatMap BUTTON_VALUES = new Int2FloatOpenHashMap();
+    private int prevTargetMouseX = 0;
+    private int prevTargetMouseY = 0;
+    private int targetMouseX = 0;
+    private int targetMouseY = 0;
+
+    protected InputManager() {
+    }
+
+    public void tick(@NotNull MinecraftClient client) {
+        if (MidnightControlsConfig.controlsMode == ControlsMode.CONTROLLER) {
+            this.controllerTick(client);
+        }
+    }
+
+    public void controllerTick(@NotNull MinecraftClient client) {
+        this.prevTargetMouseX = this.targetMouseX;
+        this.prevTargetMouseY = this.targetMouseY;
+    }
+
+    /**
+     * Updates the mouse position. Should only be called on pre render of a screen.
+     *
+     * @param client the client instance
+     */
+    public void updateMousePosition(@NotNull MinecraftClient client) {
+        Objects.requireNonNull(client, "Client instance cannot be null.");
+        if (this.prevTargetMouseX != this.targetMouseX || this.prevTargetMouseY != this.targetMouseY) {
+            double mouseX = this.prevTargetMouseX + (this.targetMouseX - this.prevTargetMouseX) * client.getTickDelta() + 0.5;
+            double mouseY = this.prevTargetMouseY + (this.targetMouseY - this.prevTargetMouseY) * client.getTickDelta() + 0.5;
+            if (!MidnightControlsConfig.virtualMouse)
+                GLFW.glfwSetCursorPos(client.getWindow().getHandle(), mouseX, mouseY);
+            ((MouseAccessor) client.mouse).midnightcontrols$onCursorPos(client.getWindow().getHandle(), mouseX, mouseY);
+        }
+    }
+
+    /**
+     * Resets the mouse position.
+     *
+     * @param windowWidth the window width
+     * @param windowHeight the window height
+     */
+    public void resetMousePosition(int windowWidth, int windowHeight) {
+        this.targetMouseX = this.prevTargetMouseX = (int) (windowWidth / 2.F);
+        this.targetMouseY = this.prevTargetMouseY = (int) (windowHeight / 2.F);
+    }
+
+    public void resetMouseTarget(@NotNull MinecraftClient client) {
+        double mouseX = client.mouse.getX();
+        double mouseY = client.mouse.getY();
+        this.prevTargetMouseX = this.targetMouseX = (int) mouseX;
+        this.prevTargetMouseY = this.targetMouseY = (int) mouseY;
+    }
+
+    /**
+     * Returns whether the specified binding is registered or not.
+     *
+     * @param binding the binding to check
+     * @return true if the binding is registered, else false
+     */
+    public static boolean hasBinding(@NotNull ButtonBinding binding) {
+        return BINDINGS.contains(binding);
+    }
+
+    /**
+     * Returns whether the specified binding is registered or not.
+     *
+     * @param name the name of the binding to check
+     * @return true if the binding is registered, else false
+     */
+    public static boolean hasBinding(@NotNull String name) {
+        return BINDINGS.parallelStream().map(ButtonBinding::getName).anyMatch(binding -> binding.equalsIgnoreCase(name));
+    }
+
+    /**
+     * Returns whether the specified binding is registered or not.
+     *
+     * @param identifier the identifier of the binding to check
+     * @return true if the binding is registered, else false
+     */
+    public static boolean hasBinding(@NotNull Identifier identifier) {
+        return hasBinding(identifier.getNamespace() + "." + identifier.getName());
+    }
+
+    /**
+     * Registers a button binding.
+     *
+     * @param binding the binding to register
+     * @return the registered binding
+     */
+    public static @NotNull ButtonBinding registerBinding(@NotNull ButtonBinding binding) {
+        if (hasBinding(binding))
+            throw new IllegalStateException("Cannot register twice a button binding in the registry.");
+        BINDINGS.add(binding);
+        return binding;
+    }
+
+    public static @NotNull ButtonBinding registerBinding(@NotNull Identifier id, int[] defaultButton, @NotNull List<PressAction> actions, @NotNull PairPredicate<MinecraftClient, ButtonBinding> filter, boolean hasCooldown) {
+        return registerBinding(new ButtonBinding(id.getNamespace() + "." + id.getName(), defaultButton, actions, filter, hasCooldown));
+    }
+
+    public static @NotNull ButtonBinding registerBinding(@NotNull Identifier id, int[] defaultButton, boolean hasCooldown) {
+        return registerBinding(id, defaultButton, Collections.emptyList(), InputHandlers::always, hasCooldown);
+    }
+
+    public static @NotNull ButtonBinding registerBinding(@NotNull net.minecraft.util.Identifier id, int[] defaultButton, @NotNull List<PressAction> actions, @NotNull PairPredicate<MinecraftClient, ButtonBinding> filter, boolean hasCooldown) {
+        return registerBinding(new Identifier(id.getNamespace(), id.getPath()), defaultButton, actions, filter, hasCooldown);
+    }
+
+    public static @NotNull ButtonBinding registerBinding(@NotNull net.minecraft.util.Identifier id, int[] defaultButton, boolean hasCooldown) {
+        return registerBinding(id, defaultButton, Collections.emptyList(), InputHandlers::always, hasCooldown);
+    }
+
+    /**
+     * Sorts bindings to get bindings with the higher button counts first.
+     */
+    public static void sortBindings() {
+        synchronized (BINDINGS) {
+            var sorted = BINDINGS.stream()
+                    .sorted(Collections.reverseOrder(Comparator.comparingInt(binding -> binding.getButton().length))).toList();
+            BINDINGS.clear();
+            BINDINGS.addAll(sorted);
+        }
+    }
+
+    /**
+     * Registers a category of button bindings.
+     *
+     * @param category the category to register
+     * @return the registered category
+     */
+    public static ButtonCategory registerCategory(@NotNull ButtonCategory category) {
+        CATEGORIES.add(category);
+        return category;
+    }
+
+    public static ButtonCategory registerCategory(@NotNull Identifier identifier, int priority) {
+        return registerCategory(new ButtonCategory(identifier, priority));
+    }
+
+    public static ButtonCategory registerCategory(@NotNull Identifier identifier) {
+        return registerCategory(new ButtonCategory(identifier));
+    }
+
+    protected static ButtonCategory registerDefaultCategory(@NotNull String key, @NotNull Consumer<ButtonCategory> keyAdder) {
+        var category = registerCategory(new Identifier("minecraft", key), CATEGORIES.size());
+        keyAdder.accept(category);
+        return category;
+    }
+
+    /**
+     * Loads the button bindings from configuration.
+     */
+    public static void loadButtonBindings() {
+        var queue = new ArrayList<>(BINDINGS);
+        queue.forEach(MidnightControlsConfig::loadButtonBinding);
+    }
+
+    /**
+     * Returns the binding state.
+     *
+     * @param binding the binding
+     * @return the current state of the binding
+     */
+    public static @NotNull ButtonState getBindingState(@NotNull ButtonBinding binding) {
+        var state = ButtonState.REPEAT;
+        for (int btn : binding.getButton()) {
+            var btnState = InputManager.STATES.getOrDefault(btn, ButtonState.NONE);
+            if (btnState == ButtonState.PRESS)
+                state = ButtonState.PRESS;
+            else if (btnState == ButtonState.RELEASE) {
+                state = ButtonState.RELEASE;
+                break;
+            } else if (btnState == ButtonState.NONE) {
+                state = ButtonState.NONE;
+                break;
+            }
+        }
+        return state;
+    }
+
+    public static float getBindingValue(@NotNull ButtonBinding binding, @NotNull ButtonState state) {
+        if (state.isUnpressed())
+            return 0.f;
+
+        float value = 0.f;
+        for (int btn : binding.getButton()) {
+            if (ButtonBinding.isAxis(btn)) {
+                value = BUTTON_VALUES.getOrDefault(btn, 1.f);
+                break;
+            } else {
+                value = 1.f;
+            }
+        }
+        return value;
+    }
+
+    /**
+     * Returns whether the button has duplicated bindings.
+     *
+     * @param button the button to check
+     * @return true if the button has duplicated bindings, else false
+     */
+    public static boolean hasDuplicatedBindings(int[] button) {
+        return BINDINGS.parallelStream().filter(binding -> areButtonsEquivalent(binding.getButton(), button)).count() > 1;
+    }
+
+    /**
+     * Returns whether the button has duplicated bindings.
+     *
+     * @param binding the binding to check
+     * @return true if the button has duplicated bindings, else false
+     */
+    public static boolean hasDuplicatedBindings(ButtonBinding binding) {
+        return BINDINGS.parallelStream().filter(other -> areButtonsEquivalent(other.getButton(), binding.getButton()) && other.filter.equals(binding.filter)).count() > 1;
+    }
+
+    /**
+     * Returns whether the specified buttons are equivalent or not.
+     *
+     * @param buttons1 first set of buttons
+     * @param buttons2 second set of buttons
+     * @return true if the two sets of buttons are equivalent, else false
+     */
+    public static boolean areButtonsEquivalent(int[] buttons1, int[] buttons2) {
+        if (buttons1.length != buttons2.length)
+            return false;
+        int count = 0;
+        for (int btn : buttons1) {
+            for (int btn2 : buttons2) {
+                if (btn == btn2) {
+                    count++;
+                    break;
+                }
+            }
+        }
+        return count == buttons1.length;
+    }
+
+    /**
+     * Returns whether the button set contains the specified button or not.
+     *
+     * @param buttons the button set
+     * @param button the button to check
+     * @return true if the button set contains the specified button, else false
+     */
+    public static boolean containsButton(int[] buttons, int button) {
+        return Arrays.stream(buttons).anyMatch(btn -> btn == button);
+    }
+
+    /**
+     * Updates the button states.
+     */
+    public static void updateStates() {
+        for (var entry : STATES.int2ObjectEntrySet()) {
+            if (entry.getValue() == ButtonState.PRESS)
+                STATES.put(entry.getIntKey(), ButtonState.REPEAT);
+            else if (entry.getValue() == ButtonState.RELEASE)
+                STATES.put(entry.getIntKey(), ButtonState.NONE);
+        }
+    }
+
+    public static void updateBindings(@NotNull MinecraftClient client) {
+        var skipButtons = new IntArrayList();
+        record ButtonStateValue(ButtonState state, float value) {
+        }
+        var states = new Object2ObjectOpenHashMap<ButtonBinding, ButtonStateValue>();
+        for (var binding : BINDINGS) {
+            var state = binding.isAvailable(client) ? getBindingState(binding) : ButtonState.NONE;
+            if (skipButtons.intStream().anyMatch(btn -> containsButton(binding.getButton(), btn))) {
+                if (binding.pressed)
+                    state = ButtonState.RELEASE;
+                else
+                    state = ButtonState.NONE;
+            }
+
+            if (state == ButtonState.RELEASE && !binding.pressed) {
+                state = ButtonState.NONE;
+            }
+
+            binding.pressed = state.isPressed();
+            binding.update();
+            if (binding.pressed)
+                Arrays.stream(binding.getButton()).forEach(skipButtons::add);
+
+            float value = getBindingValue(binding, state);
+
+            states.put(binding, new ButtonStateValue(state, value));
+        }
+
+        states.forEach((binding, state) -> {
+            if (state.state() != ButtonState.NONE) {
+                binding.handle(client, state.value(), state.state());
+            }
+        });
+    }
+
+    public static void queueMousePosition(double x, double y) {
+        INPUT_MANAGER.targetMouseX = (int) MathHelper.clamp(x, 0, MinecraftClient.getInstance().getWindow().getWidth());
+        INPUT_MANAGER.targetMouseY = (int) MathHelper.clamp(y, 0, MinecraftClient.getInstance().getWindow().getHeight());
+    }
+
+    public static void queueMoveMousePosition(double x, double y) {
+        queueMousePosition(INPUT_MANAGER.targetMouseX + x, INPUT_MANAGER.targetMouseY + y);
+    }
+
+    public static @NotNull Stream<ButtonBinding> streamBindings() {
+        return BINDINGS.stream();
+    }
+
+    public static @NotNull Stream<ButtonCategory> streamCategories() {
+        return CATEGORIES.stream();
+    }
+
+    /**
+     * Returns a new key binding instance.
+     *
+     * @param id the identifier of the key binding
+     * @param type the type
+     * @param code the code
+     * @param category the category of the key binding
+     * @return the key binding
+     * @see #makeKeyBinding(Identifier, InputUtil.Type, int, String)
+     */
+    public static @NotNull KeyBinding makeKeyBinding(@NotNull net.minecraft.util.Identifier id, InputUtil.Type type, int code, @NotNull String category) {
+        return makeKeyBinding(new Identifier(id.getNamespace(), id.getPath()), type, code, category);
+    }
+
+    /**
+     * Returns a new key binding instance.
+     *
+     * @param id the identifier of the key binding
+     * @param type the type
+     * @param code the code
+     * @param category the category of the key binding
+     * @return the key binding
+     * @see #makeKeyBinding(net.minecraft.util.Identifier, InputUtil.Type, int, String)
+     */
+    public static @NotNull KeyBinding makeKeyBinding(@NotNull Identifier id, InputUtil.Type type, int code, @NotNull String category) {
+        return new KeyBinding(String.format("key.%s.%s", id.getNamespace(), id.getName()), type, code, category);
+    }
+}
--- a/src/main/java/eu/midnightdust/midnightcontrols/client/controller/MovementHandler.java
+++ b/src/main/java/eu/midnightdust/midnightcontrols/client/controller/MovementHandler.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright © 2021 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of midnightcontrols.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package eu.midnightdust.midnightcontrols.client.controller;
+
+import eu.midnightdust.midnightcontrols.client.ButtonState;
+import eu.midnightdust.midnightcontrols.client.MidnightControlsClient;
+import eu.midnightdust.midnightcontrols.client.MidnightControlsConfig;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.network.ClientPlayerEntity;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Represents the movement handler.
+ *
+ * @author LambdAurora
+ * @version 1.6.0
+ * @since 1.4.0
+ */
+public final class MovementHandler implements PressAction {
+    public static final MovementHandler HANDLER = new MovementHandler();
+    private boolean shouldOverrideMovement = false;
+    private boolean pressingForward = false;
+    private boolean pressingBack = false;
+    private boolean pressingLeft = false;
+    private boolean pressingRight = false;
+    private float movementForward = 0.f;
+    private float movementSideways = 0.f;
+
+    private MovementHandler() {
+    }
+
+    /**
+     * Applies movement input of this handler to the player's input.
+     *
+     * @param player The client player.
+     */
+    public void applyMovement(@NotNull ClientPlayerEntity player) {
+        if (!this.shouldOverrideMovement)
+            return;
+        player.input.pressingForward = this.pressingForward;
+        player.input.pressingBack = this.pressingBack;
+        player.input.pressingLeft = this.pressingLeft;
+        player.input.pressingRight = this.pressingRight;
+        player.input.movementForward = this.movementForward;
+        player.input.movementSideways = this.movementSideways;
+        this.shouldOverrideMovement = false;
+    }
+
+    @Override
+    public boolean press(@NotNull MinecraftClient client, @NotNull ButtonBinding button, float value, @NotNull ButtonState action) {
+        if (client.currentScreen != null || client.player == null)
+            return this.shouldOverrideMovement = false;
+
+        int direction = 0;
+        if (button == ButtonBinding.FORWARD || button == ButtonBinding.LEFT)
+            direction = 1;
+        else if (button == ButtonBinding.BACK || button == ButtonBinding.RIGHT)
+            direction = -1;
+
+        if (action.isUnpressed())
+            direction = 0;
+
+        this.shouldOverrideMovement = direction != 0;
+
+        if (MidnightControlsConfig.analogMovement) {
+            value = (float) Math.pow(value, 2);
+        } else value = 1.f;
+
+        if (button == ButtonBinding.FORWARD || button == ButtonBinding.BACK) {
+            // Handle forward movement.
+            this.pressingForward = direction > 0;
+            this.pressingBack = direction < 0;
+            this.movementForward = direction * value;
+
+            // Slowing down if sneaking.
+            if (client.player.input.sneaking)
+                this.movementForward *= 0.3D;
+        } else {
+            // Handle sideways movement.
+            this.pressingLeft = direction > 0;
+            this.pressingRight = direction < 0;
+            this.movementSideways = direction * value;
+
+            // Slowing down if sneaking.
+            if (client.player.input.sneaking)
+                this.movementSideways *= 0.3D;
+        }
+
+        return this.shouldOverrideMovement;
+    }
+}
--- a/src/main/java/eu/midnightdust/midnightcontrols/client/controller/PressAction.java
+++ b/src/main/java/eu/midnightdust/midnightcontrols/client/controller/PressAction.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2021 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of midnightcontrols.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package eu.midnightdust.midnightcontrols.client.controller;
+
+import eu.midnightdust.midnightcontrols.client.ButtonState;
+import eu.midnightdust.midnightcontrols.client.util.KeyBindingAccessor;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.option.StickyKeyBinding;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Represents a press action callback.
+ *
+ * @author LambdAurora
+ * @version 1.7.0
+ * @since 1.0.0
+ */
+@FunctionalInterface
+public interface PressAction {
+    PressAction DEFAULT_ACTION = (client, button, value, action) -> {
+        if (action == ButtonState.REPEAT || client.currentScreen != null)
+            return false;
+        button.asKeyBinding().ifPresent(binding -> {
+            if (binding instanceof StickyKeyBinding)
+                binding.setPressed(button.pressed);
+            else
+                ((KeyBindingAccessor) binding).midnightcontrols$handlePressState(button.isButtonDown());
+        });
+        return true;
+    };
+
+    /**
+     * Handles when there is a press action.
+     *
+     * @param client the client instance
+     * @param action the action done
+     */
+    boolean press(@NotNull MinecraftClient client, @NotNull ButtonBinding button, float value, @NotNull ButtonState action);
+}