🔖 LambdaControls v1.4.1: Fix crash with REI.

.gitignore

@@ -1,11 +1,13 @@
 #
 # LambdAurora's ignore file
 #
-# v0.12
+# v0.13
 
 # JetBrains
 .idea/
 *.iml
+*.ipr
+*.iws
 ## Intellij IDEA
 out/
 ## CLion

CHANGELOG.md

@@ -0,0 +1,91 @@
+# Changelog
+
+## v1.0.0
+
+:tada: First release! :tada: 
+
+- Added controller support.
+- Added new controls settings GUI.
+- Added experimental touchscreen support.
+- Added controller controls GUI.
+- Added a lot of options.
+- Added key bindings for look around.
+- And more!
+
+### v1.0.1
+
+- Fixed tutorial toast to look around not affected by camera movement done with a controller. ([#2](https://github.com/LambdAurora/LambdaControls/issues/2))
+
+### v1.0.2 (Unofficial)
+
+This update was never pushed but was aiming to fix [#4](https://github.com/LambdAurora/LambdaControls/issues/4).
+
+- Fixed the toggle sneak button binding.
+- Fixed broken chat arrow keys.
+- Optimized a little bit the button indicator. (need more work)
+
+## v1.1.0 - Chording update
+
+This update also has a backport 1.14.4 version ([#9](https://github.com/LambdAurora/LambdaControls/issues/9)).
+
+- Rewrote everything (almost).
+- Added [networking](https://github.com/LambdAurora/LambdaControls/wiki/LambdaControls-Networking) for some features.
+- Added second controller support (Joycons supported now hopefully).
+- Added chording.
+- Added better developer API
+- Added hover messages ([#5](https://github.com/LambdAurora/LambdaControls/issues/5)).
+- Added hotbar button bindings ([#7](https://github.com/LambdAurora/LambdaControls/issues/7)).
+- Added front block placing feature ([#8](https://github.com/LambdAurora/LambdaControls/issues/8)).
+- Added no creative fly drifting ([#8](https://github.com/LambdAurora/LambdaControls/issues/8)).
+- Added option to enable controller focus.
+- Added [OkZoomer](https://github.com/joaoh1/OkZoomer) compatibility.
+- Added D-pad movements in inventories.
+- Increased max speed ranges.
+- Added [SpruceUI](https://github.com/LambdAurora/SpruceUI) for cleaner custom UI widgets.
+- Added reset settings button.
+- HUD side affects button indicators now.
+- Added support for Advancements tabs.
+
+### v1.1.1
+
+## v1.2.0-1.3.0
+
+- Improved rotation algorithm ([#11](https://github.com/LambdAurora/LambdaControls/issues/11)).
+- Added virtual mouse.
+- Added outline on front block placing.
+- Added fast block placement ([#8](https://github.com/LambdAurora/LambdaControls/issues/8)).
+- Added [REI](https://www.curseforge.com/minecraft/mc-mods/roughly-enough-items) compatibility.
+- Improved HUD.
+- Added recipe book control.
+- And more!
+- v1.3.0 specific: Updated to Minecraft 1.16.1
+
+### v1.3.1
+
+- Fixed broken inventory interactions ([#13](https://github.com/LambdAurora/LambdaControls/issues/13))
+- Fixed virtual mouse preventing continuous attack (thus making breaking blocks impossible).
+- Added support for [ModUpdater](https://gitea.thebrokenrail.com/TheBrokenRail/ModUpdater) hopefully.
+- Updated [SpruceUI](https://github.com/LambdAurora/SpruceUI) to 1.5.2.
+
+### v1.3.2
+
+- Added vertical reacharound.
+- Added more API for compatibility handlers.
+- Improved reacharound API.
+- Improved [REI](https://www.curseforge.com/minecraft/mc-mods/roughly-enough-items) compatibility.
+
+## v1.4.0
+
+ - Added analog movements ([#10](https://github.com/LambdAurora/LambdaControls/issues/10)).
+ - Improved Ok Zoomer compability.
+ - Updated [SpruceUI](https://github.com/LambdAurora/SpruceUI) to 1.5.8 to ensure 1.16.2 compability.
+ - Internal changes:
+   - Added analog input value to button bindings.
+   - Replace lot of strings with Texts.
+   - Improved block outline rendering injection.
+   - Shadow library jars instead of Jar-in-Jar.
+ - Fixed crash in inventory ([#16](https://github.com/LambdAurora/LambdaControls/issues/16))
+ - WIP:
+   - Started to work on action ring.
+     - Will allow for better compability with other mods.
+     - Might be interesting for keyboard users too.

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright © 2019 LambdAurora <aurora42lambda@gmail.com>
+Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -3,6 +3,43 @@
 ![Java 8](https://img.shields.io/badge/language-Java%208-9B599A.svg?style=flat-square)
 [![GitHub license](https://img.shields.io/github/license/LambdAurora/LambdaControls?style=flat-square)](https://raw.githubusercontent.com/LambdAurora/LambdaControls/master/LICENSE)
 ![Environment: Client](https://img.shields.io/badge/environment-client-1976d2?style=flat-square)
+![Mod loader: Fabric](https://img.shields.io/badge/modloader-Fabric-1976d2?style=flat-square&logo=data:image/png;base64,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)
+![Version](https://img.shields.io/github/v/tag/LambdAurora/LambdaControls?label=version&style=flat-square)
+[![CurseForge](http://cf.way2muchnoise.eu/title/354231.svg)](https://www.curseforge.com/minecraft/mc-mods/lambdacontrols)
 
-A Fabric Minecraft mod which add better controls.
-It allows the use of a controller or the touchscreen.
+A Fabric Minecraft mod which adds better controls, reach-around and controller support.
+
+## What's this mod?
+
+This mod adds better controls, reach-around features, etc.
+
+Haven't you dreamed to travel in your modded Minecraft world with your controller? Yes? Then this mod is made for you!
+
+This mod also adds controller support.
+
+## ✅ Features:
+
+ - Controller support
+ - Touchscreen support (very experimental and buggy).
+ - Keyboard controls to look around.
+ - Toggleable on screen button indicator (like in Bedrock Edition).
+ - Vertical reach-around.
+ - Many Bedrock Edition features:
+   - Toggleable fly drifting
+   - Front block placing (be careful with this one)
+ - New controls settings!
+ - Many options in config to change to your liking.
+ - Many controllers supported and in a simply way your own controller mappings.
+ - An easy API for developers to add their own button bindings.
+
+## 🎮 Supported Controllers:
+
+ - Dualshock controllers
+ - Xbox controllers
+ - Switch Pro controllers
+ - Joycons
+ - And many more!
+
+## Build
+
+Just do `./gradlew :fabric:shadowRemapJar` and everything should build just fine!

build.gradle

@@ -1,88 +1,41 @@
 plugins {
-	id 'fabric-loom' version '0.2.6-SNAPSHOT'
+	id 'java-library'
 	id 'maven-publish'
 }
 
-sourceCompatibility = JavaVersion.VERSION_1_8
-targetCompatibility = JavaVersion.VERSION_1_8
+allprojects {
+	group = project.maven_group
+	version = project.mod_version
 
-archivesBaseName = project.archives_base_name
-version = project.mod_version
-group = project.maven_group
-
-minecraft {
-}
-
-repositories {
-	mavenLocal()
-    mavenCentral()
-	maven { url = 'https://aperlambda.github.io/maven' }
-	maven {
-		name = 'CottonMC'
-		url = 'http://server.bbkr.space:8081/artifactory/libs-snapshot'
-	}
 	repositories {
-		maven { url = "https://jitpack.io" }
+		mavenLocal()
+		mavenCentral()
+		maven { url = 'https://aperlambda.github.io/maven' }
+	}
+
+	dependencies {
+	}
+
+	tasks.withType(JavaCompile) {
+		options.encoding = "UTF-8"
+	}
+
+	publishing {
+		repositories {
+			mavenLocal()
+			maven {
+				name = "GithubPackages"
+				url = uri("https://maven.pkg.github.com/LambdAurora/LambdaControls")
+				credentials {
+					username = project.findProperty("gpr.user") ?: System.getenv("USERNAME")
+					password = project.findProperty("gpr.key") ?: System.getenv("TOKEN")
+				}
+			}
+		}
 	}
 }
 
-dependencies {
-	//to change the versions see the gradle.properties file
-	minecraft "com.mojang:minecraft:${project.minecraft_version}"
-	mappings "net.fabricmc:yarn:${project.yarn_mappings}"
-	modCompile "net.fabricmc:fabric-loader:${project.loader_version}"
-
-	// Fabric API. This is technically optional, but you probably want it anyway.
-	modApi "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
-
-	modCompile "io.github.prospector:modmenu:1.8.0+build.16"
-	//modCompile "io.github.cottonmc:cotton-client-commands:0.4.2+1.14.3-SNAPSHOT"
-
-	implementation "org.jetbrains:annotations:17.0.0"
-	implementation "org.aperlambda:lambdajcommon:1.7.2"
-	implementation "com.electronwill.night-config:core:3.5.3"
-	implementation "com.electronwill.night-config:toml:3.5.3"
-	include "org.jetbrains:annotations:17.0.0"
-	include "org.aperlambda:lambdajcommon:1.7.2"
-	include "com.electronwill.night-config:core:3.5.3"
-	include "com.electronwill.night-config:toml:3.5.3"
-
-	// PSA: Some older mods, compiled on Loom 0.2.1, might have outdated Maven POMs.
-	// You may need to force-disable transitiveness on them.
-}
-
-processResources {
-	inputs.property "version", project.version
-
-	from(sourceSets.main.resources.srcDirs) {
-		include "fabric.mod.json"
-		expand "version": project.version
-	}
-
-	from(sourceSets.main.resources.srcDirs) {
-		exclude "fabric.mod.json"
-	}
-}
-
-// ensure that the encoding is set to UTF-8, no matter what the system default is
-// this fixes some edge cases with special characters not displaying correctly
-// see http://yodaconditions.net/blog/fix-for-java-file-encoding-problems-with-gradle.html
-tasks.withType(JavaCompile) {
-	options.encoding = "UTF-8"
-}
-
-// Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the "build" task
-// if it is present.
-// If you remove this task, sources will not be generated.
-task sourcesJar(type: Jar, dependsOn: classes) {
-	classifier = "sources"
-	from sourceSets.main.allSource
-}
-
-jar {
-	from "LICENSE"
-}
-
+/*
 // configure the maven publication
 publishing {
 	publications {
@@ -101,4 +54,4 @@ publishing {
 	repositories {
 		mavenLocal()
 	}
-}
+}*/

core/build.gradle

@@ -0,0 +1,32 @@
+plugins {
+    id 'java-library'
+    id 'maven-publish'
+}
+
+archivesBaseName = project.archives_base_name + "-core"
+
+dependencies {
+    api "org.jetbrains:annotations:17.0.0"
+    api "org.aperlambda:lambdajcommon:1.8.0"
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+
+    withSourcesJar()
+}
+
+publishing {
+    publications {
+        mavenJava(MavenPublication) {
+            // add all the jars that should be included when publishing to maven
+            artifact(jar) {
+                builtBy jar
+            }
+            artifact(sourcesJar) {
+                builtBy sourcesJar
+            }
+        }
+    }
+}

core/src/main/java/me/lambdaurora/lambdacontrols/ControlsMode.java

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2019 LambdAurora <aurora42lambda@gmail.com>
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
  *
  * This file is part of LambdaControls.
  *
@@ -9,7 +9,6 @@
 
 package me.lambdaurora.lambdacontrols;
 
-import net.minecraft.client.resource.language.I18n;
 import org.aperlambda.lambdacommon.utils.Nameable;
 import org.jetbrains.annotations.NotNull;
 
@@ -18,6 +17,10 @@ import java.util.Optional;
 
 /**
  * Represents the controls mode.
+ *
+ * @author LambdAurora
+ * @version 1.1.0
+ * @since 1.0.0
  */
 public enum ControlsMode implements Nameable
 {
@@ -39,17 +42,18 @@ public enum ControlsMode implements Nameable
     }
 
     /**
-     * Gets the translated name of this controls mode.
+     * Gets the translation key of this controls mode.
      *
-     * @return The translated name of this controls mode.
+     * @return The translated key of this controls mode.
+     * @since 1.1.0
      */
-    public String get_translated_name()
+    public String getTranslationKey()
     {
-        return I18n.translate("lambdacontrols.controls_mode." + this.get_name());
+        return "lambdacontrols.controls_mode." + this.getName();
     }
 
     @Override
-    public @NotNull String get_name()
+    public @NotNull String getName()
     {
         return this.name().toLowerCase();
     }
@@ -60,8 +64,8 @@ public enum ControlsMode implements Nameable
      * @param id The identifier of the controls mode.
      * @return The controls mode if found, else empty.
      */
-    public static Optional<ControlsMode> by_id(@NotNull String id)
+    public static Optional<ControlsMode> byId(@NotNull String id)
     {
-        return Arrays.stream(values()).filter(mode -> mode.get_name().equalsIgnoreCase(id)).findFirst();
+        return Arrays.stream(values()).filter(mode -> mode.getName().equalsIgnoreCase(id)).findFirst();
     }
 }

core/src/main/java/me/lambdaurora/lambdacontrols/LambdaControlsConstants.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols;
+
+import org.aperlambda.lambdacommon.Identifier;
+
+/**
+ * Represents the constants used by LambdaControls.
+ *
+ * @author LambdAurora
+ * @version 1.1.0
+ * @since 1.1.0
+ */
+public class LambdaControlsConstants
+{
+    public static final String     NAMESPACE             = "lambdacontrols";
+    public static final Identifier CONTROLS_MODE_CHANNEL = new Identifier(NAMESPACE, "controls_mode");
+    public static final Identifier FEATURE_CHANNEL       = new Identifier(NAMESPACE, "feature");
+    public static final Identifier HELLO_CHANNEL         = new Identifier(NAMESPACE, "hello");
+}

core/src/main/java/me/lambdaurora/lambdacontrols/LambdaControlsFeature.java

@@ -0,0 +1,163 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols;
+
+import org.aperlambda.lambdacommon.utils.Nameable;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * Represents a feature.
+ *
+ * @author LambdAurora
+ * @version 1.3.2
+ * @since 1.1.0
+ */
+public class LambdaControlsFeature implements Nameable
+{
+    private static final List<LambdaControlsFeature> FEATURES             = new ArrayList<>();
+    public static final  LambdaControlsFeature       FAST_BLOCK_PLACING   = new LambdaControlsFeature("fast_block_placing", true, true);
+    public static final  LambdaControlsFeature       FRONT_BLOCK_PLACING  = new LambdaControlsFeature("front_block_placing", true, false);
+    public static final  LambdaControlsFeature       VERTICAL_REACHAROUND = new LambdaControlsFeature("vertical_reacharound", true, false);
+
+    private final String  key;
+    private final boolean defaultAllowed;
+    private       boolean allowed;
+    private final boolean defaultEnabled;
+    private       boolean enabled;
+
+    public LambdaControlsFeature(@NotNull String key, boolean allowed, boolean enabled)
+    {
+        Objects.requireNonNull(key, "Feature key cannot be null.");
+        this.key = key;
+        this.setAllowed(this.defaultAllowed = allowed);
+        this.setEnabled(this.defaultEnabled = enabled);
+    }
+
+    public LambdaControlsFeature(@NotNull String key)
+    {
+        this(key, false, false);
+    }
+
+    /**
+     * Allows the feature.
+     */
+    public void allow()
+    {
+        this.setAllowed(true);
+    }
+
+    /**
+     * Returns whether this feature is allowed.
+     *
+     * @return True if this feature is allowed, else false.
+     */
+    public boolean isAllowed()
+    {
+        return this.allowed;
+    }
+
+    /**
+     * Sets whether this feature is allowed.
+     *
+     * @param allowed True if this feature is allowed, else false.
+     */
+    public void setAllowed(boolean allowed)
+    {
+        this.allowed = allowed;
+    }
+
+    /**
+     * Resets allowed state to default.
+     */
+    public void resetAllowed()
+    {
+        this.setAllowed(this.defaultAllowed);
+    }
+
+    /**
+     * Returns whether this feature is enabled.
+     *
+     * @return True if this feature is enabled, else false.
+     */
+    public boolean isEnabled()
+    {
+        return this.enabled;
+    }
+
+    /**
+     * Returns whether this feature is enabled.
+     *
+     * @param enabled True if this feature is enabled, else false.
+     */
+    public void setEnabled(boolean enabled)
+    {
+        this.enabled = enabled;
+    }
+
+    /**
+     * Returns whether this feature is available or not.
+     *
+     * @return True if this feature is available, else false.
+     * @see #isAllowed()
+     * @see #isEnabled()
+     */
+    public boolean isAvailable()
+    {
+        return this.isAllowed() && this.isEnabled();
+    }
+
+    /**
+     * Resets the feature to its default values.
+     */
+    public void reset()
+    {
+        this.resetAllowed();
+        this.setEnabled(this.defaultEnabled);
+    }
+
+    @Override
+    public @NotNull String getName()
+    {
+        return this.key;
+    }
+
+    public static @NotNull Optional<LambdaControlsFeature> fromName(@NotNull String key)
+    {
+        Objects.requireNonNull(key, "Cannot find features with a null name.");
+        return FEATURES.parallelStream().filter(feature -> feature.getName().equals(key)).findFirst();
+    }
+
+    /**
+     * Resets all features to their default values.
+     */
+    public static void resetAll()
+    {
+        FEATURES.parallelStream().forEach(LambdaControlsFeature::reset);
+    }
+
+    /**
+     * Resets all features to allow state.
+     */
+    public static void resetAllAllowed()
+    {
+        FEATURES.parallelStream().forEach(LambdaControlsFeature::resetAllowed);
+    }
+
+    static {
+        FEATURES.add(FAST_BLOCK_PLACING);
+        FEATURES.add(FRONT_BLOCK_PLACING);
+        FEATURES.add(VERTICAL_REACHAROUND);
+    }
+}

elytra/build.gradle

@@ -0,0 +1,21 @@
+plugins {
+    id 'java-library'
+}
+
+archivesBaseName = project.archives_base_name + "-elytra"
+
+repositories {
+    maven { url = 'https://hub.spigotmc.org/nexus/content/groups/public/' }
+    maven { url = 'https://mcelytra.github.io/maven/' }
+    maven { url = 'https://libraries.minecraft.net/' }
+}
+
+dependencies {
+    api project(":core")
+    implementation "org.mcelytra:elytra-core:1.0.0-SNAPSHOT"
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}

elytra/src/main/java/me/lambdaurora/lambdacontrols/event/PlayerControlsModeEvent.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.event;
+
+import me.lambdaurora.lambdacontrols.ControlsMode;
+import me.lambdaurora.lambdacontrols.LambdaControlsConstants;
+import org.aperlambda.lambdacommon.Identifier;
+import org.jetbrains.annotations.NotNull;
+import org.mcelytra.core.entity.EntityPlayer;
+import org.mcelytra.core.event.HandlerList;
+import org.mcelytra.core.event.player.PlayerEvent;
+
+/**
+ * Represents an event which is fired when a player change their controls mode.
+ *
+ * @author LambdAurora
+ * @version 1.1.0
+ * @since 1.1.0
+ */
+public class PlayerControlsModeEvent extends PlayerEvent
+{
+    private static final HandlerList  HANDLERS = new HandlerList();
+    private final        ControlsMode controlsMode;
+
+    public PlayerControlsModeEvent(@NotNull EntityPlayer player, @NotNull ControlsMode controlsMode)
+    {
+        super(new Identifier(LambdaControlsConstants.NAMESPACE, "player_controls_mode"), player, true);
+        this.controlsMode = controlsMode;
+    }
+
+    /**
+     * Returns the controls mode of the player.
+     *
+     * @return The player's controls mode.
+     */
+    public ControlsMode getControlsMode()
+    {
+        return this.controlsMode;
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers()
+    {
+        return HANDLERS;
+    }
+}

fabric/build.gradle

@@ -0,0 +1,137 @@
+import net.fabricmc.loom.task.RemapJarTask
+
+plugins {
+    id 'fabric-loom' version '0.4-SNAPSHOT'
+    id 'java-library'
+    id 'maven-publish'
+}
+
+version = "${project.mod_version}+${project.minecraft_version}"
+archivesBaseName = project.archives_base_name + "-fabric"
+
+minecraft {
+}
+
+repositories {
+    maven {
+        name = 'CottonMC'
+        url = 'http://server.bbkr.space:8081/artifactory/libs-snapshot'
+    }
+    repositories {
+        maven { url = "https://jitpack.io" }
+    }
+    // OkZoomer
+    ivy {
+        url 'https://github.com/joaoh1/OkZoomer/releases/download/'
+        patternLayout {
+            artifact '[revision]/[module]-[revision].[ext]'
+        }
+        metadataSources() {
+            artifact()
+        }
+    }
+}
+
+configurations {
+    shadowInternal
+    shadow
+    api.extendsFrom shadow
+}
+
+dependencies {
+    //to change the versions see the gradle.properties file
+    minecraft "com.mojang:minecraft:${project.minecraft_version}"
+    mappings "net.fabricmc:yarn:${project.yarn_mappings}"
+    modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
+
+    // Fabric API. This is technically optional, but you probably want it anyway.
+    modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
+
+    modImplementation "io.github.prospector:modmenu:${project.modmenu_version}"
+    modImplementation "com.github.lambdaurora:spruceui:${project.spruceui_version}"
+    include "com.github.lambdaurora:spruceui:${project.spruceui_version}"
+
+    // Compatibility mods
+    modImplementation "io.github.joaoh1:okzoomer:4.0.0-alpha.4.1.16.1"
+    modImplementation "me.shedaniel:RoughlyEnoughItems:4.5.5"
+
+    api project(":core")
+    shadowInternal project(":core")
+    shadow("org.aperlambda:lambdajcommon:1.8.0") {
+        // Minecraft already has all that google crap.
+        exclude group: 'com.google.code.gson'
+        exclude group: 'com.google.guava'
+    }
+    shadow "com.electronwill.night-config:core:3.5.3"
+    shadow "com.electronwill.night-config:toml:3.5.3"
+}
+
+processResources {
+    inputs.property "version", project.version
+
+    from(sourceSets.main.resources.srcDirs) {
+        include "fabric.mod.json"
+        expand "version": project.version
+    }
+
+    from(sourceSets.main.resources.srcDirs) {
+        exclude "fabric.mod.json"
+    }
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+
+    withSourcesJar()
+}
+
+jar {
+    from "../LICENSE"
+}
+
+task shadowJar(type: Jar) {
+    archiveClassifier.set("dev")
+
+    from sourceSets.main.output
+
+    from {
+        configurations.shadowInternal.filter {
+            it.getName().contains("lambdacontrols")
+        }.collect {
+            it.isDirectory() ? it : zipTree(it)
+        }
+    }
+    from {
+        configurations.shadow.collect {
+            it.isDirectory() ? it : zipTree(it)
+        }
+    }
+}
+
+task shadowRemapJar(type: RemapJarTask) {
+    dependsOn shadowJar
+
+    input = file("${project.buildDir}/libs/$archivesBaseName-$version-dev.jar")
+    archiveName = "${archivesBaseName}-${version}.jar"
+    addNestedDependencies = true
+}
+
+// configure the maven publication
+publishing {
+    publications {
+        mavenJava(MavenPublication) {
+            // add all the jars that should be included when publishing to maven
+            artifact(remapJar) {
+                builtBy remapJar
+            }
+            artifact(sourcesJar) {
+                builtBy remapSourcesJar
+            }
+        }
+    }
+}
+
+shadowJar.dependsOn(":core:jar")
+build.dependsOn(":core:build")
+publish.dependsOn(":core:publish")

fabric/src/main/java/me/lambdaurora/lambdacontrols/LambdaControls.java

@@ -0,0 +1,132 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols;
+
+import io.netty.buffer.Unpooled;
+import me.lambdaurora.lambdacontrols.event.PlayerChangeControlsModeCallback;
+import net.fabricmc.api.ModInitializer;
+import net.fabricmc.fabric.api.network.ServerSidePacketRegistry;
+import net.fabricmc.loader.api.FabricLoader;
+import net.fabricmc.loader.api.ModContainer;
+import net.minecraft.network.PacketByteBuf;
+import net.minecraft.text.TranslatableText;
+import net.minecraft.util.Identifier;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * Represents the LambdaControls mod.
+ *
+ * @author LambdAurora
+ * @version 1.3.0
+ * @since 1.0.0
+ */
+public class LambdaControls implements ModInitializer
+{
+    private static      LambdaControls INSTANCE;
+    public static final Identifier     CONTROLS_MODE_CHANNEL = new Identifier(LambdaControlsConstants.CONTROLS_MODE_CHANNEL.toString());
+    public static final Identifier     FEATURE_CHANNEL       = new Identifier(LambdaControlsConstants.FEATURE_CHANNEL.toString());
+    public static final Identifier     HELLO_CHANNEL         = new Identifier(LambdaControlsConstants.HELLO_CHANNEL.toString());
+
+    public static final TranslatableText NOT_BOUND_TEXT = new TranslatableText("lambdacontrols.not_bound");
+
+    public final Logger logger = LogManager.getLogger("LambdaControls");
+
+    @Override
+    public void onInitialize()
+    {
+        INSTANCE = this;
+        this.log("Initializing LambdaControls...");
+
+        ServerSidePacketRegistry.INSTANCE.register(HELLO_CHANNEL,
+                (context, attachedData) -> {
+                    String version = attachedData.readString(16);
+                    ControlsMode.byId(attachedData.readString(32))
+                            .ifPresent(controlsMode -> context.getTaskQueue()
+                                    .execute(() -> PlayerChangeControlsModeCallback.EVENT.invoker().apply(context.getPlayer(), controlsMode)));
+                    context.getTaskQueue().execute(() ->
+                            ServerSidePacketRegistry.INSTANCE.sendToPlayer(context.getPlayer(), FEATURE_CHANNEL, this.makeFeatureBuffer(LambdaControlsFeature.FRONT_BLOCK_PLACING)));
+                });
+        ServerSidePacketRegistry.INSTANCE.register(CONTROLS_MODE_CHANNEL,
+                (context, attachedData) -> ControlsMode.byId(attachedData.readString(32))
+                        .ifPresent(controlsMode -> context.getTaskQueue()
+                                .execute(() -> PlayerChangeControlsModeCallback.EVENT.invoker().apply(context.getPlayer(), controlsMode))));
+    }
+
+    /**
+     * Prints a message to the terminal.
+     *
+     * @param info The message to print.
+     */
+    public void log(String info)
+    {
+        this.logger.info("[LambdaControls] " + info);
+    }
+
+    /**
+     * Prints a warning to the terminal.
+     *
+     * @param warning The warning to print.
+     */
+    public void warn(String warning)
+    {
+        this.logger.info("[LambdaControls] " + warning);
+    }
+
+    /**
+     * Returns a packet byte buffer made for the lambdacontrols:controls_mode plugin message.
+     *
+     * @param controlsMode The controls mode to send.
+     * @return The packet byte buffer.
+     */
+    public PacketByteBuf makeControlsModeBuffer(@NotNull ControlsMode controlsMode)
+    {
+        Objects.requireNonNull(controlsMode, "Controls mode cannot be null.");
+        return new PacketByteBuf(Unpooled.buffer()).writeString(controlsMode.getName(), 32);
+    }
+
+    /**
+     * Returns a packet byte buffer made for the lambdacontrols:feature plugin message.
+     *
+     * @param feature The feature data to send.
+     * @return The packet byte buffer.
+     */
+    public PacketByteBuf makeFeatureBuffer(@NotNull LambdaControlsFeature feature)
+    {
+        Objects.requireNonNull(feature, "Feature cannot be null.");
+        PacketByteBuf buffer = new PacketByteBuf(Unpooled.buffer()).writeString(feature.getName(), 64);
+        buffer.writeBoolean(feature.isAllowed());
+        return buffer;
+    }
+
+    public PacketByteBuf makeHello(@NotNull ControlsMode controlsMode)
+    {
+        String version = "";
+        Optional<ModContainer> container;
+        if ((container = FabricLoader.getInstance().getModContainer(LambdaControlsConstants.NAMESPACE)).isPresent()) {
+            version = container.get().getMetadata().getVersion().getFriendlyString();
+        }
+        return new PacketByteBuf(Unpooled.buffer()).writeString(version, 16).writeString(controlsMode.getName(), 32);
+    }
+
+    /**
+     * Gets the LambdaControls instance.
+     *
+     * @return The LambdaControls instance.
+     */
+    public static LambdaControls get()
+    {
+        return INSTANCE;
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/ButtonState.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client;
+
+/**
+ * Represents a button state.
+ *
+ * @author LambdAurora
+ * @version 1.1.0
+ * @since 1.1.0
+ */
+public enum ButtonState
+{
+    NONE(0),
+    PRESS(1),
+    RELEASE(2),
+    REPEAT(3);
+
+    public final int id;
+
+    ButtonState(int id)
+    {
+        this.id = id;
+    }
+
+    /**
+     * Returns whether this state is a pressed state.
+     *
+     * @return True if this state is a pressed state, else false.
+     */
+    public boolean isPressed()
+    {
+        return this == PRESS || this == REPEAT;
+    }
+
+    /**
+     * Returns whether this state is an unpressed state.
+     *
+     * @return True if this state is an unpressed state, else false.
+     */
+    public boolean isUnpressed()
+    {
+        return this == RELEASE || this == NONE;
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/ControllerType.java

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2019 LambdAurora <aurora42lambda@gmail.com>
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
  *
  * This file is part of LambdaControls.
  *
@@ -7,9 +7,10 @@
  * see the LICENSE file.
  */
 
-package me.lambdaurora.lambdacontrols;
+package me.lambdaurora.lambdacontrols.client;
 
-import net.minecraft.client.resource.language.I18n;
+import net.minecraft.text.Text;
+import net.minecraft.text.TranslatableText;
 import org.aperlambda.lambdacommon.utils.Nameable;
 import org.jetbrains.annotations.NotNull;
 
@@ -18,6 +19,10 @@ import java.util.Optional;
 
 /**
  * Represents a controller type.
+ *
+ * @author LambdAurora
+ * @version 1.4.0
+ * @since 1.0.0
  */
 public enum ControllerType implements Nameable
 {
@@ -28,11 +33,13 @@ public enum ControllerType implements Nameable
     STEAM(4),
     OUYA(5);
 
-    private final int id;
+    private final int  id;
+    private final Text text;
 
     ControllerType(int id)
     {
         this.id = id;
+        this.text = new TranslatableText(this.getTranslationKey());
     }
 
     /**
@@ -40,7 +47,7 @@ public enum ControllerType implements Nameable
      *
      * @return The controller type's identifier.
      */
-    public int get_id()
+    public int getId()
     {
         return this.id;
     }
@@ -50,7 +57,7 @@ public enum ControllerType implements Nameable
      *
      * @return The next available controller type.
      */
-    public ControllerType next()
+    public @NotNull ControllerType next()
     {
         ControllerType[] v = values();
         if (v.length == this.ordinal() + 1)
@@ -59,17 +66,27 @@ public enum ControllerType implements Nameable
     }
 
     /**
-     * Gets the translated name of this controller type.
+     * Returns the translation key of this controller type.
      *
-     * @return The translated name of this controller type.
+     * @return The translation key.
      */
-    public String get_translated_name()
+    public @NotNull String getTranslationKey()
     {
-        return I18n.translate("lambdacontrols.controller_type." + this.get_name());
+        return "lambdacontrols.controller_type." + this.getName();
+    }
+
+    /**
+     * Gets the translated text of this controller type.
+     *
+     * @return The translated text of this controller type.
+     */
+    public @NotNull Text getTranslatedText()
+    {
+        return this.text;
     }
 
     @Override
-    public @NotNull String get_name()
+    public @NotNull String getName()
     {
         return this.name().toLowerCase();
     }
@@ -80,8 +97,8 @@ public enum ControllerType implements Nameable
      * @param id The identifier of the controller type.
      * @return The controller type if found, else empty.
      */
-    public static Optional<ControllerType> by_id(@NotNull String id)
+    public static @NotNull Optional<ControllerType> byId(@NotNull String id)
     {
-        return Arrays.stream(values()).filter(mode -> mode.get_name().equalsIgnoreCase(id)).findFirst();
+        return Arrays.stream(values()).filter(mode -> mode.getName().equalsIgnoreCase(id)).findFirst();
     }
 }

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/HudSide.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client;
+
+import net.minecraft.client.resource.language.I18n;
+import net.minecraft.text.Text;
+import net.minecraft.text.TranslatableText;
+import org.aperlambda.lambdacommon.utils.Nameable;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+/**
+ * Represents the hud side which is the side where the movements buttons are.
+ *
+ * @author LambdAurora
+ * @version 1.4.0
+ * @since 1.0.0
+ */
+public enum HudSide implements Nameable
+{
+    LEFT,
+    RIGHT;
+
+    private final Text text;
+
+    HudSide()
+    {
+        this.text = new TranslatableText(this.getTranslationKey());
+    }
+
+    /**
+     * Returns the next side available.
+     *
+     * @return The next available side.
+     */
+    public @NotNull HudSide next()
+    {
+        HudSide[] v = values();
+        if (v.length == this.ordinal() + 1)
+            return v[0];
+        return v[this.ordinal() + 1];
+    }
+
+    /**
+     * Returns the translation key of this hud side.
+     *
+     * @return The translation key of this hude side.
+     */
+    public @NotNull String getTranslationKey()
+    {
+        return "lambdacontrols.hud_side." + this.getName();
+    }
+
+    /**
+     * Gets the translated text of this hud side.
+     *
+     * @return The translated text of this hud side.
+     */
+    public @NotNull Text getTranslatedText()
+    {
+        return this.text;
+    }
+
+    @Override
+    public @NotNull String getName()
+    {
+        return this.name().toLowerCase();
+    }
+
+    /**
+     * Gets the hud side from its identifier.
+     *
+     * @param id The identifier of the hud side.
+     * @return The hud side if found, else empty.
+     */
+    public static @NotNull Optional<HudSide> byId(@NotNull String id)
+    {
+        return Arrays.stream(values()).filter(mode -> mode.getName().equalsIgnoreCase(id)).findFirst();
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/LambdaControlsClient.java

@@ -0,0 +1,188 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client;
+
+import me.lambdaurora.lambdacontrols.ControlsMode;
+import me.lambdaurora.lambdacontrols.LambdaControls;
+import me.lambdaurora.lambdacontrols.LambdaControlsConstants;
+import me.lambdaurora.lambdacontrols.LambdaControlsFeature;
+import me.lambdaurora.lambdacontrols.client.compat.LambdaControlsCompat;
+import me.lambdaurora.lambdacontrols.client.controller.ButtonBinding;
+import me.lambdaurora.lambdacontrols.client.controller.Controller;
+import me.lambdaurora.lambdacontrols.client.controller.InputManager;
+import me.lambdaurora.lambdacontrols.client.gui.LambdaControlsHud;
+import me.lambdaurora.lambdacontrols.client.gui.TouchscreenOverlay;
+import me.lambdaurora.spruceui.event.OpenScreenCallback;
+import me.lambdaurora.spruceui.hud.HudManager;
+import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper;
+import net.fabricmc.fabric.api.network.ClientSidePacketRegistry;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.options.KeyBinding;
+import net.minecraft.client.toast.SystemToast;
+import net.minecraft.client.util.InputUtil;
+import net.minecraft.text.LiteralText;
+import net.minecraft.text.TranslatableText;
+import net.minecraft.util.Identifier;
+import org.jetbrains.annotations.NotNull;
+import org.lwjgl.glfw.GLFW;
+
+/**
+ * Represents the LambdaControls client mod.
+ *
+ * @author LambdAurora
+ * @version 1.3.2
+ * @since 1.1.0
+ */
+public class LambdaControlsClient extends LambdaControls implements ClientModInitializer
+{
+    private static      LambdaControlsClient INSTANCE;
+    public static final KeyBinding           BINDING_LOOK_UP    = InputManager.makeKeyBinding(new Identifier(LambdaControlsConstants.NAMESPACE, "look_up"),
+            InputUtil.Type.KEYSYM, GLFW.GLFW_KEY_KP_8, "key.categories.movement");
+    public static final KeyBinding           BINDING_LOOK_RIGHT = InputManager.makeKeyBinding(new Identifier(LambdaControlsConstants.NAMESPACE, "look_right"),
+            InputUtil.Type.KEYSYM, GLFW.GLFW_KEY_KP_6, "key.categories.movement");
+    public static final KeyBinding           BINDING_LOOK_DOWN  = InputManager.makeKeyBinding(new Identifier(LambdaControlsConstants.NAMESPACE, "look_down"),
+            InputUtil.Type.KEYSYM, GLFW.GLFW_KEY_KP_2, "key.categories.movement");
+    public static final KeyBinding           BINDING_LOOK_LEFT  = InputManager.makeKeyBinding(new Identifier(LambdaControlsConstants.NAMESPACE, "look_left"),
+            InputUtil.Type.KEYSYM, GLFW.GLFW_KEY_KP_4, "key.categories.movement");
+    public static final Identifier           CONTROLLER_BUTTONS = new Identifier(LambdaControlsConstants.NAMESPACE, "textures/gui/controller_buttons.png");
+    public static final Identifier           CONTROLLER_AXIS    = new Identifier(LambdaControlsConstants.NAMESPACE, "textures/gui/controller_axis.png");
+    public static final Identifier           CURSOR_TEXTURE     = new Identifier(LambdaControlsConstants.NAMESPACE, "textures/gui/cursor.png");
+    public final        LambdaControlsConfig config             = new LambdaControlsConfig(this);
+    public final        LambdaInput          input              = new LambdaInput(this);
+    public final        LambdaReacharound    reacharound        = new LambdaReacharound();
+    private             LambdaControlsHud    hud;
+    private             ControlsMode         previousControlsMode;
+
+    @Override
+    public void onInitializeClient()
+    {
+        INSTANCE = this;
+        KeyBindingHelper.registerKeyBinding(BINDING_LOOK_UP);
+        KeyBindingHelper.registerKeyBinding(BINDING_LOOK_RIGHT);
+        KeyBindingHelper.registerKeyBinding(BINDING_LOOK_DOWN);
+        KeyBindingHelper.registerKeyBinding(BINDING_LOOK_LEFT);
+
+        ClientSidePacketRegistry.INSTANCE.register(CONTROLS_MODE_CHANNEL, (context, attachedData) -> context.getTaskQueue()
+                .execute(() -> ClientSidePacketRegistry.INSTANCE.sendToServer(CONTROLS_MODE_CHANNEL, this.makeControlsModeBuffer(this.config.getControlsMode()))));
+        ClientSidePacketRegistry.INSTANCE.register(FEATURE_CHANNEL, (context, attachedData) -> {
+            String name = attachedData.readString(64);
+            boolean allowed = attachedData.readBoolean();
+            LambdaControlsFeature.fromName(name).ifPresent(feature -> context.getTaskQueue().execute(() -> feature.setAllowed(allowed)));
+        });
+
+        ClientTickEvents.START_CLIENT_TICK.register(this.reacharound::tick);
+        ClientTickEvents.END_CLIENT_TICK.register(this::onTick);
+
+        OpenScreenCallback.EVENT.register((client, screen) -> {
+            if (screen == null && this.config.getControlsMode() == ControlsMode.TOUCHSCREEN) {
+                screen = new TouchscreenOverlay(this);
+                screen.init(client, client.getWindow().getScaledWidth(), client.getWindow().getScaledHeight());
+                client.skipGameRender = false;
+                client.currentScreen = screen;
+            } else if (screen != null) {
+                this.input.onScreenOpen(client, client.getWindow().getWidth(), client.getWindow().getHeight());
+            }
+        });
+
+        HudManager.register(this.hud = new LambdaControlsHud(this));
+    }
+
+    /**
+     * This method is called when Minecraft is initializing.
+     */
+    public void onMcInit(@NotNull MinecraftClient client)
+    {
+        ButtonBinding.init(client.options);
+        this.config.load();
+        this.hud.setVisible(this.config.isHudEnabled());
+        Controller.updateMappings();
+        GLFW.glfwSetJoystickCallback((jid, event) -> {
+            if (event == GLFW.GLFW_CONNECTED) {
+                Controller controller = Controller.byId(jid);
+                client.getToastManager().add(new SystemToast(SystemToast.Type.TUTORIAL_HINT, new TranslatableText("lambdacontrols.controller.connected", jid),
+                        new LiteralText(controller.getName())));
+            } else if (event == GLFW.GLFW_DISCONNECTED) {
+                client.getToastManager().add(new SystemToast(SystemToast.Type.TUTORIAL_HINT, new TranslatableText("lambdacontrols.controller.disconnected", jid),
+                        null));
+            }
+
+            this.switchControlsMode();
+        });
+
+        LambdaControlsCompat.init(this);
+    }
+
+    /**
+     * This method is called every Minecraft tick.
+     *
+     * @param client The client instance.
+     */
+    public void onTick(@NotNull MinecraftClient client)
+    {
+        this.input.onTick(client);
+        if (this.config.getControlsMode() == ControlsMode.CONTROLLER && (client.isWindowFocused() || this.config.hasUnfocusedInput()))
+            this.input.onControllerTick(client);
+    }
+
+    public void onRender(MinecraftClient client)
+    {
+        this.input.onRender(client.getTickDelta(), client);
+    }
+
+    /**
+     * Called when leaving a server.
+     */
+    public void onLeave()
+    {
+        LambdaControlsFeature.resetAllAllowed();
+    }
+
+    /**
+     * Switches the controls mode if the auto switch is enabled.
+     */
+    public void switchControlsMode()
+    {
+        if (this.config.hasAutoSwitchMode()) {
+            if (this.config.getController().isGamepad()) {
+                this.previousControlsMode = this.config.getControlsMode();
+                this.config.setControlsMode(ControlsMode.CONTROLLER);
+            } else {
+                if (this.previousControlsMode == null) {
+                    this.previousControlsMode = ControlsMode.DEFAULT;
+                }
+
+                this.config.setControlsMode(this.previousControlsMode);
+            }
+        }
+    }
+
+    /**
+     * Sets whether the HUD is enabled or not.
+     *
+     * @param enabled True if the HUD is enabled, else false.
+     */
+    public void setHudEnabled(boolean enabled)
+    {
+        this.config.setHudEnabled(enabled);
+        this.hud.setVisible(enabled);
+    }
+
+    /**
+     * Gets the LambdaControls client instance.
+     *
+     * @return The LambdaControls client instance.
+     */
+    public static LambdaControlsClient get()
+    {
+        return INSTANCE;
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/LambdaControlsConfig.java

@@ -0,0 +1,808 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client;
+
+import com.electronwill.nightconfig.core.file.FileConfig;
+import me.lambdaurora.lambdacontrols.ControlsMode;
+import me.lambdaurora.lambdacontrols.LambdaControlsFeature;
+import me.lambdaurora.lambdacontrols.client.controller.ButtonBinding;
+import me.lambdaurora.lambdacontrols.client.controller.Controller;
+import me.lambdaurora.lambdacontrols.client.controller.InputManager;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.lwjgl.glfw.GLFW;
+
+import java.util.Arrays;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import static org.lwjgl.glfw.GLFW.GLFW_GAMEPAD_AXIS_LEFT_X;
+import static org.lwjgl.glfw.GLFW.GLFW_GAMEPAD_AXIS_LEFT_Y;
+
+/**
+ * Represents LambdaControls configuration.
+ */
+public class LambdaControlsConfig
+{
+    // General
+    private static final ControlsMode     DEFAULT_CONTROLS_MODE             = ControlsMode.DEFAULT;
+    private static final boolean          DEFAULT_AUTO_SWITCH_MODE          = false;
+    // HUD
+    private static final boolean          DEFAULT_HUD_ENABLE                = true;
+    private static final HudSide          DEFAULT_HUD_SIDE                  = HudSide.LEFT;
+    // Gameplay
+    private static final boolean          DEFAULT_FAST_BLOCK_INTERACTION    = true;
+    private static final boolean          DEFAULT_FLY_DRIFTING              = false;
+    private static final boolean          DEFAULT_FLY_VERTICAL_DRIFTING     = true;
+    private static final boolean          DEFAULT_FRONT_BLOCK_PLACING       = false;
+    private static final boolean          DEFAULT_VERTICAL_REACHAROUND      = false;
+    private static final boolean          DEFAULT_REACHAROUND_OUTLINE       = true;
+    private static final int[]            DEFAULT_REACHAROUND_OUTLINE_COLOR = new int[]{255, 255, 255, 102};
+    // Controller
+    private static final ControllerType   DEFAULT_CONTROLLER_TYPE           = ControllerType.DEFAULT;
+    private static final double           DEFAULT_DEAD_ZONE                 = 0.25;
+    private static final double           DEFAULT_ROTATION_SPEED            = 40.0;
+    private static final double           DEFAULT_MOUSE_SPEED               = 25.0;
+    private static final boolean          DEFAULT_UNFOCUSED_INPUT           = false;
+    private static final boolean          DEFAULT_VIRTUAL_MOUSE             = false;
+    private static final VirtualMouseSkin DEFAULT_VIRTUAL_MOUSE_SKIN        = VirtualMouseSkin.DEFAULT_LIGHT;
+
+    private static final Pattern BUTTON_BINDING_PATTERN = Pattern.compile("(-?\\d+)\\+?");
+
+    protected final FileConfig           config = FileConfig.builder("config/lambdacontrols.toml").concurrent().defaultResource("/config.toml").build();
+    private final   LambdaControlsClient mod;
+    private         ControlsMode         controlsMode;
+    private         ControllerType       controllerType;
+    // Gameplay.
+    private         boolean              shouldRenderReacharoundOutline;
+    private         int[]                reacharoundOutlineColor;
+    // Controller settings
+    private         double               deadZone;
+    private         double               rotationSpeed;
+    private         double               mouseSpeed;
+    private         boolean              unfocusedInput;
+    private         boolean              virtualMouse;
+    private         VirtualMouseSkin     virtualMouseSkin;
+    // HUD settings.
+    private         boolean              hudEnable;
+    private         HudSide              hudSide;
+
+    public LambdaControlsConfig(@NotNull LambdaControlsClient mod)
+    {
+        this.mod = mod;
+    }
+
+    /**
+     * Loads the configuration
+     */
+    public void load()
+    {
+        this.config.load();
+        this.checkAndFix();
+        this.mod.log("Configuration loaded.");
+        this.controlsMode = ControlsMode.byId(this.config.getOrElse("controls", DEFAULT_CONTROLS_MODE.getName())).orElse(DEFAULT_CONTROLS_MODE);
+        // HUD settings.
+        this.hudEnable = this.config.getOrElse("hud.enable", DEFAULT_HUD_ENABLE);
+        this.hudSide = HudSide.byId(this.config.getOrElse("hud.side", DEFAULT_HUD_SIDE.getName())).orElse(DEFAULT_HUD_SIDE);
+        // Gameplay
+        LambdaControlsFeature.FAST_BLOCK_PLACING.setEnabled(this.config.getOrElse("gameplay.fast_block_placing", DEFAULT_FAST_BLOCK_INTERACTION));
+        LambdaControlsFeature.FRONT_BLOCK_PLACING.setEnabled(this.config.getOrElse("gameplay.reacharound.horizontal", DEFAULT_FRONT_BLOCK_PLACING));
+        LambdaControlsFeature.VERTICAL_REACHAROUND.setEnabled(this.config.getOrElse("gameplay.reacharound.vertical", DEFAULT_VERTICAL_REACHAROUND));
+        this.shouldRenderReacharoundOutline = this.config.getOrElse("gameplay.reacharound.outline", DEFAULT_REACHAROUND_OUTLINE);
+        this.reacharoundOutlineColor = this.config.getOptional("gameplay.reacharound.outline_color").map(hex -> parseColor((String) hex)).orElse(DEFAULT_REACHAROUND_OUTLINE_COLOR);
+        // Controller settings.
+        this.controllerType = ControllerType.byId(this.config.getOrElse("controller.type", DEFAULT_CONTROLLER_TYPE.getName())).orElse(DEFAULT_CONTROLLER_TYPE);
+        this.deadZone = this.config.getOrElse("controller.dead_zone", DEFAULT_DEAD_ZONE);
+        this.rotationSpeed = this.config.getOrElse("controller.rotation_speed", DEFAULT_ROTATION_SPEED);
+        this.mouseSpeed = this.config.getOrElse("controller.mouse_speed", DEFAULT_MOUSE_SPEED);
+        this.unfocusedInput = this.config.getOrElse("controller.unfocused_input", DEFAULT_UNFOCUSED_INPUT);
+        this.virtualMouse = this.config.getOrElse("controller.virtual_mouse", DEFAULT_VIRTUAL_MOUSE);
+        this.virtualMouseSkin = VirtualMouseSkin.byId(this.config.getOrElse("controller.virtual_mouse_skin", DEFAULT_VIRTUAL_MOUSE_SKIN.getName())).orElse(DEFAULT_VIRTUAL_MOUSE_SKIN);
+        // Controller controls.
+        InputManager.loadButtonBindings(this);
+    }
+
+    /**
+     * Saves the configuration.
+     */
+    public void save()
+    {
+        this.config.set("controller.dead_zone", this.deadZone);
+        this.config.set("controller.rotation_speed", this.rotationSpeed);
+        this.config.set("controller.mouse_speed", this.mouseSpeed);
+        this.config.set("controller.unfocused_input", this.unfocusedInput);
+        this.config.set("controller.virtual_mouse", this.virtualMouse);
+        this.config.save();
+        this.mod.log("Configuration saved.");
+    }
+
+    public void checkAndFix()
+    {
+        InputManager.streamBindings().forEach(binding -> {
+            String path = "controller.controls." + binding.getName();
+            Object raw = this.config.getRaw(path);
+            if (raw instanceof Number) {
+                this.mod.warn("Invalid data at \"" + path + "\", fixing...");
+                this.config.set(path, String.valueOf(raw));
+            }
+        });
+
+        if (this.config.contains("gameplay.front_block_placing.enabled")) {
+            this.setFrontBlockPlacing(this.config.getOrElse("gameplay.front_block_placing.enabled", DEFAULT_FRONT_BLOCK_PLACING));
+            this.config.remove("gameplay.front_block_placing.enabled");
+        }
+
+        if (this.config.contains("gameplay.front_block_placing.outline")) {
+            this.setRenderReacharoundOutline(this.config.getOrElse("gameplay.front_block_placing.outline", DEFAULT_REACHAROUND_OUTLINE));
+            this.config.remove("gameplay.front_block_placing.outline");
+        }
+
+        if (this.config.contains("gameplay.front_block_placing.outline_color")) {
+            this.config.getOptional("gameplay.front_block_placing.outline_color").ifPresent(color -> this.config.set("gameplay.reacharound.outline_color", color));
+            this.config.remove("gameplay.front_block_placing.outline_color");
+        }
+
+        this.renamed("controller.controls.tab_left", "controller.controls.tab_back");
+        this.renamed("controller.controls.tab_right", "controller.controls.tab_next");
+    }
+
+    private void renamed(String oldPath, String newPath)
+    {
+        if (!this.config.contains(oldPath))
+            return;
+        Object raw = this.config.getRaw(oldPath);
+        this.config.remove(oldPath);
+        this.config.set(newPath, raw);
+    }
+
+    /**
+     * Resets the configuration to default values.
+     */
+    public void reset()
+    {
+        // General
+        this.setControlsMode(DEFAULT_CONTROLS_MODE);
+        this.setAutoSwitchMode(DEFAULT_AUTO_SWITCH_MODE);
+        // Gameplay
+        this.setFastBlockPlacing(DEFAULT_FAST_BLOCK_INTERACTION);
+        this.setFlyDrifting(DEFAULT_FLY_DRIFTING);
+        this.setFlyVerticalDrifting(DEFAULT_FLY_VERTICAL_DRIFTING);
+        this.setFrontBlockPlacing(DEFAULT_FRONT_BLOCK_PLACING);
+        this.setVerticalReacharound(DEFAULT_VERTICAL_REACHAROUND);
+        this.setRenderReacharoundOutline(DEFAULT_REACHAROUND_OUTLINE);
+        // Controller
+        this.setControllerType(DEFAULT_CONTROLLER_TYPE);
+        this.setDeadZone(DEFAULT_DEAD_ZONE);
+        this.setRotationSpeed(DEFAULT_ROTATION_SPEED);
+        this.setMouseSpeed(DEFAULT_MOUSE_SPEED);
+        this.setUnfocusedInput(DEFAULT_UNFOCUSED_INPUT);
+        this.setVirtualMouse(DEFAULT_VIRTUAL_MOUSE);
+        this.setVirtualMouseSkin(DEFAULT_VIRTUAL_MOUSE_SKIN);
+        // HUD
+        this.setHudEnabled(DEFAULT_HUD_ENABLE);
+        this.setHudSide(DEFAULT_HUD_SIDE);
+
+        // Collect prevents concurrent modification.
+        InputManager.streamBindings().collect(Collectors.toList()).forEach(binding -> this.setButtonBinding(binding, binding.getDefaultButton()));
+    }
+
+    /**
+     * Gets the controls mode from the configuration.
+     *
+     * @return The controls mode.
+     */
+    public @NotNull ControlsMode getControlsMode()
+    {
+        return this.controlsMode;
+    }
+
+    /**
+     * Sets the controls mode in the configuration.
+     *
+     * @param controlsMode The controls mode.
+     */
+    public void setControlsMode(@NotNull ControlsMode controlsMode)
+    {
+        this.controlsMode = controlsMode;
+        this.config.set("controls", controlsMode.getName());
+    }
+
+    /**
+     * Returns whether the auto switch mode is enabled or not.
+     *
+     * @return True if the auto switch mode is enabled, else false.
+     */
+    public boolean hasAutoSwitchMode()
+    {
+        return this.config.getOrElse("auto_switch_mode", DEFAULT_AUTO_SWITCH_MODE);
+    }
+
+    /**
+     * Sets whether the auto switch mode is enabled or not.
+     *
+     * @param autoSwitchMode True if the auto switch mode is enabled, else false.
+     */
+    public void setAutoSwitchMode(boolean autoSwitchMode)
+    {
+        this.config.set("auto_switch_mode", autoSwitchMode);
+    }
+
+    /*
+            HUD settings
+     */
+
+    /**
+     * Returns whether the HUD is enabled.
+     *
+     * @return True if the HUD is enabled, else false.
+     */
+    public boolean isHudEnabled()
+    {
+        return this.hudEnable;
+    }
+
+    /**
+     * Sets whether the HUD is enabled.
+     *
+     * @param enable True if the HUD is enabled, else false.
+     */
+    public void setHudEnabled(boolean enable)
+    {
+        this.hudEnable = enable;
+        this.config.set("hud.enable", this.hudEnable);
+    }
+
+    /**
+     * Gets the HUD side from the configuration.
+     *
+     * @return The HUD side.
+     */
+    public @NotNull HudSide getHudSide()
+    {
+        return this.hudSide;
+    }
+
+    /**
+     * Sets the HUD side in the configuration.
+     *
+     * @param hudSide The HUD side.
+     */
+    public void setHudSide(@NotNull HudSide hudSide)
+    {
+        this.hudSide = hudSide;
+        this.config.set("hud.side", hudSide.getName());
+    }
+
+    /*
+            Gameplay settings
+     */
+
+    /**
+     * Gets whether fast block placing is enabled or not.
+     *
+     * @return True if fast block placing is enabled, else false.
+     */
+    public boolean hasFastBlockPlacing()
+    {
+        return LambdaControlsFeature.FAST_BLOCK_PLACING.isEnabled();
+    }
+
+    /**
+     * Sets whether fast block placing is enabled or not.
+     *
+     * @param enable True if fast block placing is enabled, else false.
+     */
+    public void setFastBlockPlacing(boolean enable)
+    {
+        LambdaControlsFeature.FAST_BLOCK_PLACING.setEnabled(enable);
+        this.config.set("gameplay.fast_block_placing", enable);
+    }
+
+    /**
+     * Returns whether fly drifting is enabled or not.
+     *
+     * @return True if fly drifting is enabled, else false.
+     */
+    public boolean hasFlyDrifting()
+    {
+        return this.config.getOrElse("gameplay.fly.drifting", DEFAULT_FLY_DRIFTING);
+    }
+
+    /**
+     * Sets whether fly drifting is enabled or not.
+     *
+     * @param flyDrifting True if fly drifting is enabled, else false.
+     */
+    public void setFlyDrifting(boolean flyDrifting)
+    {
+        this.config.set("gameplay.fly.drifting", flyDrifting);
+    }
+
+    /**
+     * Returns whether vertical fly drifting is enabled or not.
+     *
+     * @return True if vertical fly drifting is enabled, else false.
+     */
+    public boolean hasFlyVerticalDrifting()
+    {
+        return this.config.getOrElse("gameplay.fly.vertical_drifting", DEFAULT_FLY_VERTICAL_DRIFTING);
+    }
+
+    /**
+     * Sets whether vertical fly drifting is enabled or not.
+     *
+     * @param flyDrifting True if vertical fly drifting is enabled, else false.
+     */
+    public void setFlyVerticalDrifting(boolean flyDrifting)
+    {
+        this.config.set("gameplay.fly.vertical_drifting", flyDrifting);
+    }
+
+    /**
+     * Returns whether front block placing is enabled or not.
+     *
+     * @return True if front block placing is enabled, else false.
+     */
+    public boolean hasFrontBlockPlacing()
+    {
+        return LambdaControlsFeature.FRONT_BLOCK_PLACING.isEnabled();
+    }
+
+    /**
+     * Sets whether front block placing is enabled or not.
+     *
+     * @param enable True if front block placing is enabled, else false.
+     */
+    public void setFrontBlockPlacing(boolean enable)
+    {
+        LambdaControlsFeature.FRONT_BLOCK_PLACING.setEnabled(enable);
+        this.config.set("gameplay.reacharound.horizontal", enable);
+    }
+
+    /**
+     * Returns whether vertical reacharound is enabled or not.
+     *
+     * @return True if vertical reacharound is enabled, else false.
+     */
+    public boolean hasVerticalReacharound()
+    {
+        return LambdaControlsFeature.VERTICAL_REACHAROUND.isEnabled();
+    }
+
+    /**
+     * Sets whether vertical reacharound is enabled or not.
+     *
+     * @param enable True if vertical reacharound is enabled, else false.
+     */
+    public void setVerticalReacharound(boolean enable)
+    {
+        LambdaControlsFeature.VERTICAL_REACHAROUND.setEnabled(enable);
+        this.config.set("gameplay.reacharound.vertical", enable);
+    }
+
+    /**
+     * Returns whether front block placing outline is enabled or not.
+     *
+     * @return True if front block placing outline is enabled, else false.
+     */
+    public boolean shouldRenderReacharoundOutline()
+    {
+        return this.shouldRenderReacharoundOutline;
+    }
+
+    /**
+     * Sets whether front block placing outline is enabled or not.
+     *
+     * @param render True if front block placing outline is enabled, else false.
+     */
+    public void setRenderReacharoundOutline(boolean render)
+    {
+        this.config.set("gameplay.reacharound.outline", this.shouldRenderReacharoundOutline = render);
+    }
+
+    /**
+     * Returns the front block placing outline color as an integer array.
+     * <p>
+     * The integer array has 4 elements: red, green, blue and alpha.
+     *
+     * @return The color as a RGBA integer array.
+     */
+    public int[] getReacharoundOutlineColor()
+    {
+        return this.reacharoundOutlineColor;
+    }
+
+    /*
+            Controller settings
+     */
+
+    /**
+     * Gets the used controller.
+     *
+     * @return The used controller.
+     */
+    public @NotNull Controller getController()
+    {
+        Object raw = this.config.getRaw("controller.id");
+        if (raw instanceof Number) {
+            return Controller.byId((Integer) raw);
+        } else if (raw instanceof String) {
+            return Controller.byGuid((String) raw).orElse(Controller.byId(GLFW.GLFW_JOYSTICK_1));
+        }
+        return Controller.byId(GLFW.GLFW_JOYSTICK_1);
+    }
+
+    /**
+     * Sets the used controller.
+     *
+     * @param controller The used controller.
+     */
+    public void setController(@NotNull Controller controller)
+    {
+        this.config.set("controller.id", controller.getId());
+    }
+
+    /**
+     * Gets the second controller (for Joy-Con supports).
+     *
+     * @return The second controller.
+     */
+    public @NotNull Optional<Controller> getSecondController()
+    {
+        Object raw = this.config.getRaw("controller.id2");
+        if (raw instanceof Number) {
+            if ((int) raw == -1)
+                return Optional.empty();
+            return Optional.of(Controller.byId((Integer) raw));
+        } else if (raw instanceof String) {
+            return Optional.of(Controller.byGuid((String) raw).orElse(Controller.byId(GLFW.GLFW_JOYSTICK_1)));
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * Sets the second controller.
+     *
+     * @param controller The second controller.
+     */
+    public void setSecondController(@Nullable Controller controller)
+    {
+        this.config.set("controller.id2", controller == null ? -1 : controller.getId());
+    }
+
+    /**
+     * Gets the controller's type.
+     *
+     * @return The controller's type.
+     */
+    public @NotNull ControllerType getControllerType()
+    {
+        return this.controllerType;
+    }
+
+    /**
+     * Sets the controller's type.
+     *
+     * @param controllerType The controller's type.
+     */
+    public void setControllerType(@NotNull ControllerType controllerType)
+    {
+        this.controllerType = controllerType;
+        this.config.set("controller.type", controllerType.getName());
+    }
+
+    /**
+     * Gets the controller's dead zone from the configuration.
+     *
+     * @return The controller's dead zone value.
+     */
+    public double getDeadZone()
+    {
+        return this.deadZone;
+    }
+
+    /**
+     * Sets the controller's dead zone in the configuration.
+     *
+     * @param deadZone The new controller's dead zone value.
+     */
+    public void setDeadZone(double deadZone)
+    {
+        this.deadZone = deadZone;
+    }
+
+    /**
+     * Gets the controller's rotation speed.
+     *
+     * @return The rotation speed.
+     */
+    public double getRotationSpeed()
+    {
+        return this.rotationSpeed;
+    }
+
+    /**
+     * Sets the controller's rotation speed.
+     *
+     * @param rotationSpeed The rotation speed.
+     */
+    public void setRotationSpeed(double rotationSpeed)
+    {
+        this.rotationSpeed = rotationSpeed;
+    }
+
+    /**
+     * Gets the controller's mouse speed.
+     *
+     * @return The mouse speed.
+     */
+    public double getMouseSpeed()
+    {
+        return this.mouseSpeed;
+    }
+
+    /**
+     * Sets the controller's mouse speed.
+     *
+     * @param mouseSpeed The mouse speed.
+     */
+    public void setMouseSpeed(double mouseSpeed)
+    {
+        this.mouseSpeed = mouseSpeed;
+    }
+
+    /**
+     * Returns whether the right X axis is inverted or not.
+     *
+     * @return True if the right X axis is inverted, else false.
+     */
+    public boolean doesInvertRightXAxis()
+    {
+        return this.config.getOrElse("controller.invert_right_x_axis", false);
+    }
+
+    /**
+     * Sets whether the right X axis is inverted or not.
+     *
+     * @param invert True if the right X axis is inverted, else false.
+     */
+    public void setInvertRightXAxis(boolean invert)
+    {
+        this.config.set("controller.invert_right_x_axis", invert);
+    }
+
+    /**
+     * Returns whether the right Y axis is inverted or not.
+     *
+     * @return True if the right Y axis is inverted, else false.
+     */
+    public boolean doesInvertRightYAxis()
+    {
+        return this.config.getOrElse("controller.invert_right_y_axis", false);
+    }
+
+    /**
+     * Sets whether the right Y axis is inverted or not.
+     *
+     * @param invert True if the right Y axis is inverted, else false.
+     */
+    public void setInvertRightYAxis(boolean invert)
+    {
+        this.config.set("controller.invert_right_y_axis", invert);
+    }
+
+    /**
+     * Returns whether unfocused controller input is allowed or not.
+     *
+     * @return True if unfocused controller input is allowed, else false.
+     */
+    public boolean hasUnfocusedInput()
+    {
+        return this.unfocusedInput;
+    }
+
+    /**
+     * Sets whether unfocused controller input is allowed or not.
+     *
+     * @param unfocusedInput True if unfocused controller input is allowed, else false.
+     */
+    public void setUnfocusedInput(boolean unfocusedInput)
+    {
+        this.unfocusedInput = unfocusedInput;
+    }
+
+    /**
+     * Returns whether the mouse is virtual or not.
+     *
+     * @return True if the mouse is virtual, else false.
+     */
+    public boolean hasVirtualMouse()
+    {
+        return this.virtualMouse;
+    }
+
+    /**
+     * Sets whether the mouse is virtual or not.
+     *
+     * @param virtualMouse True if the mouse is virtual, else false.
+     */
+    public void setVirtualMouse(boolean virtualMouse)
+    {
+        this.virtualMouse = virtualMouse;
+    }
+
+    /**
+     * Gets the virtual mouse skin.
+     *
+     * @return The virtual mouse skin.
+     */
+    public VirtualMouseSkin getVirtualMouseSkin()
+    {
+        return this.virtualMouseSkin;
+    }
+
+    /**
+     * Sets the virtual mouse skin.
+     *
+     * @param skin The virtual mouse skin.
+     */
+    public void setVirtualMouseSkin(VirtualMouseSkin skin)
+    {
+        this.virtualMouseSkin = skin;
+        this.config.set("controller.virtual_mouse_skin", skin.getName());
+    }
+
+    /**
+     * Gets the right X axis sign.
+     *
+     * @return The right X axis sign.
+     */
+    public double getRightXAxisSign()
+    {
+        return this.doesInvertRightXAxis() ? -1.0 : 1.0;
+    }
+
+    /**
+     * Gets the right Y axis sign.
+     *
+     * @return The right Y axis sign.
+     */
+    public double getRightYAxisSign()
+    {
+        return this.doesInvertRightYAxis() ? -1.0 : 1.0;
+    }
+
+    /**
+     * Loads the button binding from configuration.
+     *
+     * @param button The button binding.
+     */
+    public void loadButtonBinding(@NotNull ButtonBinding button)
+    {
+        button.setButton(button.getDefaultButton());
+        String code = this.config.getOrElse("controller.controls." + button.getName(), button.getButtonCode());
+
+        Matcher matcher = BUTTON_BINDING_PATTERN.matcher(code);
+
+        try {
+            int[] buttons = new int[1];
+            int count = 0;
+            while (matcher.find()) {
+                count++;
+                if (count > buttons.length)
+                    buttons = Arrays.copyOf(buttons, count);
+                String current;
+                if (!this.checkValidity(button, code, current = matcher.group(1)))
+                    return;
+                buttons[count - 1] = Integer.parseInt(current);
+            }
+            if (count == 0) {
+                this.mod.warn("Malformed config value \"" + code + "\" for binding \"" + button.getName() + "\".");
+                this.setButtonBinding(button, new int[]{-1});
+            }
+
+            button.setButton(buttons);
+        } catch (Exception e) {
+            this.mod.warn("Malformed config value \"" + code + "\" for binding \"" + button.getName() + "\".");
+            this.config.set("controller.controls." + button.getName(), button.getButtonCode());
+        }
+    }
+
+    private boolean checkValidity(@NotNull ButtonBinding binding, @NotNull String input, String group)
+    {
+        if (group == null) {
+            this.mod.warn("Malformed config value \"" + input + "\" for binding \"" + binding.getName() + "\".");
+            this.config.set("controller.controls." + binding.getName(), binding.getButtonCode());
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Sets the button binding in configuration.
+     *
+     * @param binding The button binding.
+     * @param button  The button.
+     */
+    public void setButtonBinding(@NotNull ButtonBinding binding, int[] button)
+    {
+        binding.setButton(button);
+        this.config.set("controller.controls." + binding.getName(), binding.getButtonCode());
+    }
+
+    public boolean isBackButton(int btn, boolean isBtn, int state)
+    {
+        if (!isBtn && state == 0)
+            return false;
+        return ButtonBinding.axisAsButton(GLFW_GAMEPAD_AXIS_LEFT_Y, false) == ButtonBinding.axisAsButton(btn, state == 1);
+    }
+
+    public boolean isForwardButton(int btn, boolean isBtn, int state)
+    {
+        if (!isBtn && state == 0)
+            return false;
+        return ButtonBinding.axisAsButton(GLFW_GAMEPAD_AXIS_LEFT_Y, true) == ButtonBinding.axisAsButton(btn, state == 1);
+    }
+
+    public boolean isLeftButton(int btn, boolean isBtn, int state)
+    {
+        if (!isBtn && state == 0)
+            return false;
+        return ButtonBinding.axisAsButton(GLFW_GAMEPAD_AXIS_LEFT_X, false) == ButtonBinding.axisAsButton(btn, state == 1);
+    }
+
+    public boolean isRightButton(int btn, boolean isBtn, int state)
+    {
+        if (!isBtn && state == 0)
+            return false;
+        return ButtonBinding.axisAsButton(GLFW_GAMEPAD_AXIS_LEFT_X, true) == ButtonBinding.axisAsButton(btn, state == 1);
+    }
+
+    /**
+     * Returns whether the specified axis is an axis used for movements.
+     *
+     * @param axis The axis index.
+     * @return True if the axis is used for movements, else false.
+     */
+    public boolean isMovementAxis(int axis)
+    {
+        return axis == GLFW_GAMEPAD_AXIS_LEFT_Y || axis == GLFW_GAMEPAD_AXIS_LEFT_X;
+    }
+
+    /**
+     * Parses a color from a hexadecimal color string.
+     *
+     * @param hex The hexadecimal color.
+     * @return The color instance, null if invalid.
+     */
+    private static int[] parseColor(String hex)
+    {
+        hex = hex.replace("#", "");
+        switch (hex.length()) {
+            case 6:
+                return new int[]{
+                        Integer.valueOf(hex.substring(0, 2), 16),
+                        Integer.valueOf(hex.substring(2, 4), 16),
+                        Integer.valueOf(hex.substring(4, 6), 16),
+                        255
+                };
+            case 8:
+                return new int[]{
+                        Integer.valueOf(hex.substring(0, 2), 16),
+                        Integer.valueOf(hex.substring(2, 4), 16),
+                        Integer.valueOf(hex.substring(4, 6), 16),
+                        Integer.valueOf(hex.substring(6, 8), 16)
+                };
+        }
+        return null;
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/LambdaControlsModMenu.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client;
+
+import io.github.prospector.modmenu.api.ConfigScreenFactory;
+import io.github.prospector.modmenu.api.ModMenuApi;
+import me.lambdaurora.lambdacontrols.client.gui.LambdaControlsSettingsScreen;
+
+/**
+ * Represents the API implementation of ModMenu for LambdaControls.
+ *
+ * @author LambdAurora
+ * @version 1.3.0
+ * @since 1.1.0
+ */
+public class LambdaControlsModMenu implements ModMenuApi
+{
+    @Override
+    public ConfigScreenFactory<?> getModConfigScreenFactory()
+    {
+        return parent -> new LambdaControlsSettingsScreen(parent, false);
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/LambdaInput.java

@@ -0,0 +1,762 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client;
+
+import com.google.common.collect.ImmutableSet;
+import me.lambdaurora.lambdacontrols.client.compat.LambdaControlsCompat;
+import me.lambdaurora.lambdacontrols.client.controller.ButtonBinding;
+import me.lambdaurora.lambdacontrols.client.controller.Controller;
+import me.lambdaurora.lambdacontrols.client.controller.InputManager;
+import me.lambdaurora.lambdacontrols.client.gui.ControllerControlsScreen;
+import me.lambdaurora.lambdacontrols.client.gui.TouchscreenOverlay;
+import me.lambdaurora.lambdacontrols.client.mixin.AdvancementsScreenAccessor;
+import me.lambdaurora.lambdacontrols.client.mixin.CreativeInventoryScreenAccessor;
+import me.lambdaurora.lambdacontrols.client.mixin.EntryListWidgetAccessor;
+import me.lambdaurora.lambdacontrols.client.util.HandledScreenAccessor;
+import me.lambdaurora.lambdacontrols.client.util.MouseAccessor;
+import me.lambdaurora.spruceui.SpruceLabelWidget;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.Element;
+import net.minecraft.client.gui.ParentElement;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.screen.advancement.AdvancementTab;
+import net.minecraft.client.gui.screen.advancement.AdvancementsScreen;
+import net.minecraft.client.gui.screen.ingame.CreativeInventoryScreen;
+import net.minecraft.client.gui.screen.ingame.HandledScreen;
+import net.minecraft.client.gui.screen.multiplayer.MultiplayerScreen;
+import net.minecraft.client.gui.screen.multiplayer.MultiplayerServerListWidget;
+import net.minecraft.client.gui.screen.pack.ResourcePackScreen;
+import net.minecraft.client.gui.screen.world.WorldListWidget;
+import net.minecraft.client.gui.widget.AbstractPressableButtonWidget;
+import net.minecraft.client.gui.widget.AlwaysSelectedEntryListWidget;
+import net.minecraft.client.gui.widget.EntryListWidget;
+import net.minecraft.client.gui.widget.SliderWidget;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.screen.slot.Slot;
+import net.minecraft.screen.slot.SlotActionType;
+import net.minecraft.text.TranslatableText;
+import net.minecraft.util.math.MathHelper;
+import org.aperlambda.lambdacommon.utils.Pair;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.lwjgl.glfw.GLFW;
+import org.lwjgl.glfw.GLFWGamepadState;
+
+import java.nio.ByteBuffer;
+import java.nio.FloatBuffer;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import static me.lambdaurora.lambdacontrols.client.controller.ButtonBinding.axisAsButton;
+import static me.lambdaurora.lambdacontrols.client.controller.InputManager.INPUT_MANAGER;
+import static org.lwjgl.glfw.GLFW.*;
+
+/**
+ * Represents the LambdaControls' input handler.
+ *
+ * @author LambdAurora
+ * @version 1.4.0
+ * @since 1.0.0
+ */
+public class LambdaInput
+{
+    private static final Map<Integer, Integer> BUTTON_COOLDOWNS             = new HashMap<>();
+    private final        LambdaControlsConfig  config;
+    // Cooldowns
+    private              int                   actionGuiCooldown            = 0;
+    private              boolean               ignoreNextARelease           = false;
+    private              double                targetYaw                    = 0.0;
+    private              double                targetPitch                  = 0.0;
+    private              float                 prevXAxis                    = 0.F;
+    private              float                 prevYAxis                    = 0.F;
+    private              int                   targetMouseX                 = 0;
+    private              int                   targetMouseY                 = 0;
+    private              float                 mouseSpeedX                  = 0.F;
+    private              float                 mouseSpeedY                  = 0.F;
+    private              int                   inventoryInteractionCooldown = 0;
+
+    public LambdaInput(@NotNull LambdaControlsClient mod)
+    {
+        this.config = mod.config;
+    }
+
+    /**
+     * This method is called every Minecraft tick.
+     *
+     * @param client The client instance.
+     */
+    public void onTick(@NotNull MinecraftClient client)
+    {
+        this.targetYaw = 0.F;
+        this.targetPitch = 0.F;
+
+        // Handles the key bindings.
+        if (LambdaControlsClient.BINDING_LOOK_UP.isPressed()) {
+            this.handleLook(client, GLFW_GAMEPAD_AXIS_RIGHT_Y, 0.8F, 2);
+        } else if (LambdaControlsClient.BINDING_LOOK_DOWN.isPressed()) {
+            this.handleLook(client, GLFW_GAMEPAD_AXIS_RIGHT_Y, 0.8F, 1);
+        }
+        if (LambdaControlsClient.BINDING_LOOK_LEFT.isPressed()) {
+            this.handleLook(client, GLFW_GAMEPAD_AXIS_RIGHT_X, 0.8F, 2);
+        } else if (LambdaControlsClient.BINDING_LOOK_RIGHT.isPressed()) {
+            this.handleLook(client, GLFW_GAMEPAD_AXIS_RIGHT_X, 0.8F, 1);
+        }
+
+        INPUT_MANAGER.tick(client);
+    }
+
+    /**
+     * This method is called every Minecraft tick for controller input update.
+     *
+     * @param client The client instance.
+     */
+    public void onControllerTick(@NotNull MinecraftClient client)
+    {
+        BUTTON_COOLDOWNS.entrySet().stream().filter(entry -> entry.getValue() > 0).forEach(entry -> BUTTON_COOLDOWNS.put(entry.getKey(), entry.getValue() - 1));
+        // Decreases the cooldown for GUI actions.
+        if (this.actionGuiCooldown > 0)
+            --this.actionGuiCooldown;
+
+        InputManager.updateStates();
+
+        Controller controller = this.config.getController();
+        if (controller.isConnected()) {
+            GLFWGamepadState state = controller.getState();
+            this.fetchButtonInput(client, state, false);
+            this.fetchAxeInput(client, state, false);
+        }
+        this.config.getSecondController().filter(Controller::isConnected)
+                .ifPresent(joycon -> {
+                    GLFWGamepadState state = joycon.getState();
+                    this.fetchButtonInput(client, state, true);
+                    this.fetchAxeInput(client, state, true);
+                });
+
+        boolean allowInput = true;
+
+        if (client.currentScreen instanceof ControllerControlsScreen && ((ControllerControlsScreen) client.currentScreen).focusedBinding != null)
+            allowInput = false;
+
+        if (allowInput)
+            InputManager.updateBindings(client);
+
+        if (client.currentScreen instanceof ControllerControlsScreen && InputManager.STATES.entrySet().parallelStream().map(Map.Entry::getValue).allMatch(ButtonState::isUnpressed)) {
+            ControllerControlsScreen screen = (ControllerControlsScreen) client.currentScreen;
+            if (screen.focusedBinding != null && !screen.waiting) {
+                int[] buttons = new int[screen.currentButtons.size()];
+                for (int i = 0; i < screen.currentButtons.size(); i++)
+                    buttons[i] = screen.currentButtons.get(i);
+                screen.focusedBinding.setButton(buttons);
+                screen.focusedBinding = null;
+            }
+        }
+
+        if (this.inventoryInteractionCooldown > 0)
+            this.inventoryInteractionCooldown--;
+    }
+
+    /**
+     * This method is called before the screen is rendered.
+     *
+     * @param client The client instance.
+     * @param screen The screen to render.
+     */
+    public void onPreRenderScreen(@NotNull MinecraftClient client, @NotNull Screen screen)
+    {
+        if (!isScreenInteractive(screen)) {
+            INPUT_MANAGER.updateMousePosition(client);
+        }
+    }
+
+    /**
+     * This method is called when Minecraft renders.
+     *
+     * @param client The client instance.
+     */
+    public void onRender(float tickDelta, @NotNull MinecraftClient client)
+    {
+        if (!(client.currentScreen == null || client.currentScreen instanceof TouchscreenOverlay))
+            return;
+
+        PlayerEntity player = client.player;
+        if (player == null)
+            return;
+
+        if (this.targetYaw != 0F || this.targetPitch != 0F) {
+            float rotationYaw = (float) (player.prevYaw + (this.targetYaw / 0.10) * tickDelta);
+            float rotationPitch = (float) (player.prevPitch + (this.targetPitch / 0.10) * tickDelta);
+            client.player.yaw = rotationYaw;
+            client.player.pitch = MathHelper.clamp(rotationPitch, -90.F, 90.F);
+            if (client.player.isRiding()) {
+                client.player.getVehicle().copyPositionAndRotation(client.player);
+            }
+            client.getTutorialManager().onUpdateMouse(this.targetPitch, this.targetYaw);
+        }
+    }
+
+    /**
+     * This method is called when a Screen is opened.
+     *
+     * @param client       The client instance.
+     * @param windowWidth  The window width.
+     * @param windowHeight The window height.
+     */
+    public void onScreenOpen(@NotNull MinecraftClient client, int windowWidth, int windowHeight)
+    {
+        if (client.currentScreen == null) {
+            this.mouseSpeedX = this.mouseSpeedY = 0.0F;
+            INPUT_MANAGER.resetMousePosition(windowWidth, windowHeight);
+        } else if (isScreenInteractive(client.currentScreen) && this.config.hasVirtualMouse()) {
+            ((MouseAccessor) client.mouse).lambdacontrols_onCursorPos(client.getWindow().getHandle(), 0, 0);
+            INPUT_MANAGER.resetMouseTarget(client);
+        }
+        this.inventoryInteractionCooldown = 5;
+    }
+
+    private void fetchButtonInput(@NotNull MinecraftClient client, @NotNull GLFWGamepadState gamepadState, boolean leftJoycon)
+    {
+        ByteBuffer buffer = gamepadState.buttons();
+        for (int i = 0; i < buffer.limit(); i++) {
+            int btn = leftJoycon ? ButtonBinding.controller2Button(i) : i;
+            boolean btnState = buffer.get() == (byte) 1;
+            ButtonState state = ButtonState.NONE;
+            ButtonState previousState = InputManager.STATES.getOrDefault(btn, ButtonState.NONE);
+
+            if (btnState != previousState.isPressed()) {
+                state = btnState ? ButtonState.PRESS : ButtonState.RELEASE;
+                this.handleButton(client, btn, btnState ? 0 : 1, btnState);
+                if (btnState)
+                    BUTTON_COOLDOWNS.put(btn, 5);
+            } else if (btnState) {
+                state = ButtonState.REPEAT;
+                if (BUTTON_COOLDOWNS.getOrDefault(btn, 0) == 0) {
+                    BUTTON_COOLDOWNS.put(btn, 5);
+                    this.handleButton(client, btn, 2, true);
+                }
+            }
+
+            InputManager.STATES.put(btn, state);
+        }
+    }
+
+    private void fetchAxeInput(@NotNull MinecraftClient client, @NotNull GLFWGamepadState gamepadState, boolean leftJoycon)
+    {
+        FloatBuffer buffer = gamepadState.axes();
+        for (int i = 0; i < buffer.limit(); i++) {
+            int axis = leftJoycon ? ButtonBinding.controller2Button(i) : i;
+            float value = buffer.get();
+            float absValue = Math.abs(value);
+
+            if (i == GLFW.GLFW_GAMEPAD_AXIS_LEFT_Y)
+                value *= -1.0F;
+
+            int state = value > this.config.getDeadZone() ? 1 : (value < -this.config.getDeadZone() ? 2 : 0);
+            this.handleAxe(client, axis, value, absValue, state);
+        }
+    }
+
+    private void handleButton(@NotNull MinecraftClient client, int button, int action, boolean state)
+    {
+        if (client.currentScreen instanceof ControllerControlsScreen) {
+            ControllerControlsScreen screen = (ControllerControlsScreen) client.currentScreen;
+            if (screen.focusedBinding != null) {
+                if (action == 0 && !screen.currentButtons.contains(button)) {
+                    screen.currentButtons.add(button);
+
+                    int[] buttons = new int[screen.currentButtons.size()];
+                    for (int i = 0; i < screen.currentButtons.size(); i++)
+                        buttons[i] = screen.currentButtons.get(i);
+                    screen.focusedBinding.setButton(buttons);
+
+                    screen.waiting = false;
+                }
+                return;
+            }
+        }
+
+        if (action == 0 || action == 2) {
+            if (client.currentScreen != null && isScreenInteractive(client.currentScreen)
+                    && (button == GLFW.GLFW_GAMEPAD_BUTTON_DPAD_UP || button == GLFW.GLFW_GAMEPAD_BUTTON_DPAD_DOWN
+                    || button == GLFW.GLFW_GAMEPAD_BUTTON_DPAD_LEFT || button == GLFW.GLFW_GAMEPAD_BUTTON_DPAD_RIGHT)) {
+                if (this.actionGuiCooldown == 0) {
+                    if (button == GLFW.GLFW_GAMEPAD_BUTTON_DPAD_UP) {
+                        this.changeFocus(client.currentScreen, false);
+                    } else if (button == GLFW.GLFW_GAMEPAD_BUTTON_DPAD_DOWN) {
+                        this.changeFocus(client.currentScreen, true);
+                    } else if (button == GLFW.GLFW_GAMEPAD_BUTTON_DPAD_LEFT) {
+                        this.handleLeftRight(client.currentScreen, false);
+                    } else {
+                        this.handleLeftRight(client.currentScreen, true);
+                    }
+                }
+                return;
+            }
+        }
+
+        if (action == 1) {
+            if (button == GLFW.GLFW_GAMEPAD_BUTTON_A && client.currentScreen != null) {
+                if (this.actionGuiCooldown == 0) {
+                    Element focused = client.currentScreen.getFocused();
+                    if (focused != null && isScreenInteractive(client.currentScreen)) {
+                        if (this.handleAButton(client.currentScreen, focused)) {
+                            this.actionGuiCooldown = 5; // Prevent to press too quickly the focused element, so we have to skip 5 ticks.
+                            return;
+                        }
+                    }
+                }
+            }
+
+            if (this.handleInventory(client, button)) {
+                this.ignoreNextARelease = true;
+                return;
+            }
+
+            if (button == GLFW.GLFW_GAMEPAD_BUTTON_B) {
+                if (client.currentScreen != null) {
+                    if (!LambdaControlsCompat.handleMenuBack(client, client.currentScreen))
+                        if (!this.tryGoBack(client.currentScreen))
+                            client.currentScreen.onClose();
+                    return;
+                }
+            }
+        }
+
+        if (button == GLFW.GLFW_GAMEPAD_BUTTON_A && client.currentScreen != null && !isScreenInteractive(client.currentScreen) && this.actionGuiCooldown == 0) {
+            if (!this.ignoreNextARelease) {
+                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();
+                if (action == 0) {
+                    Screen.wrapScreenError(() -> client.currentScreen.mouseClicked(mouseX, mouseY, GLFW.GLFW_MOUSE_BUTTON_1),
+                            "mouseClicked event handler", client.currentScreen.getClass().getCanonicalName());
+                } else if (action == 1) {
+                    Screen.wrapScreenError(() -> client.currentScreen.mouseReleased(mouseX, mouseY, GLFW.GLFW_MOUSE_BUTTON_1),
+                            "mouseReleased event handler", client.currentScreen.getClass().getCanonicalName());
+                }
+                this.actionGuiCooldown = 5;
+            } else {
+                this.ignoreNextARelease = false;
+            }
+        }
+    }
+
+    /**
+     * Handles inventory interaction.
+     *
+     * @param client The client instance.
+     * @param button The button pressed.
+     * @return True if an inventory interaction was done.
+     */
+    private boolean handleInventory(@NotNull MinecraftClient client, int button)
+    {
+        if (!(client.currentScreen instanceof HandledScreen))
+            return false;
+
+        if (client.interactionManager == null || client.player == null)
+            return false;
+
+        if (this.inventoryInteractionCooldown > 0)
+            return true;
+
+        if (button == GLFW.GLFW_GAMEPAD_BUTTON_B) {
+            client.player.closeHandledScreen();
+            return true;
+        }
+
+        double x = client.mouse.getX() * (double) client.getWindow().getScaledWidth() / (double) client.getWindow().getWidth();
+        double y = client.mouse.getY() * (double) client.getWindow().getScaledHeight() / (double) client.getWindow().getHeight();
+
+        HandledScreen screen = (HandledScreen) client.currentScreen;
+        HandledScreenAccessor accessor = (HandledScreenAccessor) screen;
+        Slot slot = ((HandledScreenAccessor) client.currentScreen).lambdacontrols_getSlotAt(x, y);
+
+        int slotId;
+        if (slot == null) {
+            if (client.player.inventory.getCursorStack().isEmpty())
+                return false;
+            slotId = accessor.lambdacontrols_isClickOutsideBounds(x, y, accessor.getX(), accessor.getY(), GLFW_MOUSE_BUTTON_1) ? -999 : -1;
+        } else {
+            slotId = slot.id;
+        }
+
+        SlotActionType actionType = SlotActionType.PICKUP;
+        int clickData = GLFW.GLFW_MOUSE_BUTTON_1;
+        switch (button) {
+            case GLFW_GAMEPAD_BUTTON_A:
+                if (screen instanceof CreativeInventoryScreen)
+                    if (((CreativeInventoryScreenAccessor) screen).lambdacontrols_isCreativeInventorySlot(slot))
+                        actionType = SlotActionType.CLONE;
+                if (slot != null && LambdaControlsCompat.streamCompatHandlers().anyMatch(handler -> handler.isCreativeSlot(screen, slot)))
+                    actionType = SlotActionType.CLONE;
+                break;
+            case GLFW.GLFW_GAMEPAD_BUTTON_X:
+                clickData = GLFW_MOUSE_BUTTON_2;
+                break;
+            case GLFW.GLFW_GAMEPAD_BUTTON_Y:
+                actionType = SlotActionType.QUICK_MOVE;
+                break;
+            default:
+                return false;
+        }
+
+        accessor.lambdacontrols_onMouseClick(slot, slotId, clickData, actionType);
+        return true;
+    }
+
+    /**
+     * Tries to go back.
+     *
+     * @param screen The current screen.
+     * @return True if successful, else false.
+     */
+    public boolean tryGoBack(@NotNull Screen screen)
+    {
+        ImmutableSet<String> set = ImmutableSet.of("gui.back", "gui.done", "gui.cancel", "gui.toTitle", "gui.toMenu");
+        return screen.children().stream().filter(element -> element instanceof AbstractPressableButtonWidget)
+                .map(element -> (AbstractPressableButtonWidget) element)
+                .filter(element -> element.getMessage() instanceof TranslatableText)
+                .anyMatch(element -> {
+                    if (set.stream().anyMatch(key -> key.equals(((TranslatableText) element.getMessage()).getKey()))) {
+                        element.onPress();
+                        return true;
+                    }
+                    return false;
+                });
+    }
+
+    private void handleAxe(@NotNull MinecraftClient client, int axis, float value, float absValue, int state)
+    {
+        int asButtonState = value > 0.5F ? 1 : (value < -0.5F ? 2 : 0);
+
+        if (axis == GLFW_GAMEPAD_AXIS_LEFT_TRIGGER || axis == GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER || axis == ButtonBinding.controller2Button(GLFW.GLFW_GAMEPAD_AXIS_LEFT_TRIGGER) ||
+                axis == ButtonBinding.controller2Button(GLFW.GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER))
+            if (asButtonState == 2)
+                asButtonState = 0;
+
+        {
+            boolean currentPlusState = asButtonState == 1;
+            boolean currentMinusState = asButtonState == 2;
+            ButtonState previousPlusState = InputManager.STATES.getOrDefault(axisAsButton(axis, true), ButtonState.NONE);
+            ButtonState previousMinusState = InputManager.STATES.getOrDefault(axisAsButton(axis, false), ButtonState.NONE);
+
+            if (currentPlusState != previousPlusState.isPressed()) {
+                InputManager.STATES.put(axisAsButton(axis, true), currentPlusState ? ButtonState.PRESS : ButtonState.RELEASE);
+                if (currentPlusState)
+                    BUTTON_COOLDOWNS.put(axisAsButton(axis, true), 5);
+            } else if (currentPlusState) {
+                InputManager.STATES.put(axisAsButton(axis, true), ButtonState.REPEAT);
+                if (BUTTON_COOLDOWNS.getOrDefault(axisAsButton(axis, true), 0) == 0) {
+                    BUTTON_COOLDOWNS.put(axisAsButton(axis, true), 5);
+                }
+            }
+
+            if (currentMinusState != previousMinusState.isPressed()) {
+                InputManager.STATES.put(axisAsButton(axis, false), currentMinusState ? ButtonState.PRESS : ButtonState.RELEASE);
+                if (currentMinusState)
+                    BUTTON_COOLDOWNS.put(axisAsButton(axis, false), 5);
+            } else if (currentMinusState) {
+                InputManager.STATES.put(axisAsButton(axis, false), ButtonState.REPEAT);
+                if (BUTTON_COOLDOWNS.getOrDefault(axisAsButton(axis, false), 0) == 0) {
+                    BUTTON_COOLDOWNS.put(axisAsButton(axis, false), 5);
+                }
+            }
+
+            float axisValue = absValue < this.config.getDeadZone() ? 0.f : (float) (absValue - this.config.getDeadZone());
+            axisValue /= (1.0 - this.config.getDeadZone());
+            if (currentPlusState)
+                InputManager.BUTTON_VALUES.put(axisAsButton(axis, true), axisValue);
+            else
+                InputManager.BUTTON_VALUES.put(axisAsButton(axis, true), 0.f);
+            if (currentMinusState)
+                InputManager.BUTTON_VALUES.put(axisAsButton(axis, false), axisValue);
+            else
+                InputManager.BUTTON_VALUES.put(axisAsButton(axis, false), 0.f);
+        }
+
+        double deadZone = this.config.getDeadZone();
+
+        if (client.currentScreen instanceof ControllerControlsScreen) {
+            ControllerControlsScreen screen = (ControllerControlsScreen) client.currentScreen;
+            if (screen.focusedBinding != null) {
+                if (asButtonState != 0 && !screen.currentButtons.contains(axisAsButton(axis, asButtonState == 1))) {
+
+                    screen.currentButtons.add(axisAsButton(axis, asButtonState == 1));
+
+                    int[] buttons = new int[screen.currentButtons.size()];
+                    for (int i = 0; i < screen.currentButtons.size(); i++)
+                        buttons[i] = screen.currentButtons.get(i);
+                    screen.focusedBinding.setButton(buttons);
+
+                    screen.waiting = false;
+                }
+                return;
+            }
+        } else if (client.currentScreen instanceof CreativeInventoryScreen) {
+            if (axis == GLFW_GAMEPAD_AXIS_RIGHT_Y) {
+                CreativeInventoryScreen screen = (CreativeInventoryScreen) client.currentScreen;
+                CreativeInventoryScreenAccessor accessor = (CreativeInventoryScreenAccessor) screen;
+                // @TODO allow rebinding to left stick
+                if (accessor.lambdacontrols_hasScrollbar() && absValue >= deadZone) {
+                    screen.mouseScrolled(0.0, 0.0, -value);
+                }
+                return;
+            }
+        } else if (client.currentScreen instanceof AdvancementsScreen) {
+            if (axis == GLFW_GAMEPAD_AXIS_RIGHT_X || axis == GLFW_GAMEPAD_AXIS_RIGHT_Y) {
+                AdvancementsScreen screen = (AdvancementsScreen) client.currentScreen;
+                AdvancementsScreenAccessor accessor = (AdvancementsScreenAccessor) screen;
+                if (absValue >= deadZone) {
+                    AdvancementTab tab = accessor.getSelectedTab();
+                    tab.move(axis == GLFW_GAMEPAD_AXIS_RIGHT_X ? -value * 5.0 : 0.0, axis == GLFW_GAMEPAD_AXIS_RIGHT_Y ? -value * 5.0 : 0.0);
+                }
+                return;
+            }
+        }
+
+        if (client.currentScreen == null) {
+            // Handles the look direction.
+            absValue -= this.config.getDeadZone();
+            this.handleLook(client, axis, (float) (absValue / (1.0 - this.config.getDeadZone())), state);
+        } else {
+            boolean allowMouseControl = true;
+
+            if (this.actionGuiCooldown == 0 && this.config.isMovementAxis(axis) && isScreenInteractive(client.currentScreen)) {
+                if (this.config.isForwardButton(axis, false, asButtonState)) {
+                    allowMouseControl = this.changeFocus(client.currentScreen, false);
+                } else if (this.config.isBackButton(axis, false, asButtonState)) {
+                    allowMouseControl = this.changeFocus(client.currentScreen, true);
+                } else if (this.config.isLeftButton(axis, false, asButtonState)) {
+                    allowMouseControl = this.handleLeftRight(client.currentScreen, false);
+                } else if (this.config.isRightButton(axis, false, asButtonState)) {
+                    allowMouseControl = this.handleLeftRight(client.currentScreen, true);
+                }
+            }
+
+            float movementX = 0.0F;
+            float movementY = 0.0F;
+
+            if (this.config.isBackButton(axis, false, (value > 0 ? 1 : 2))) {
+                movementY = absValue;
+            } else if (this.config.isForwardButton(axis, false, (value > 0 ? 1 : 2))) {
+                movementY = -absValue;
+            } else if (this.config.isLeftButton(axis, false, (value > 0 ? 1 : 2))) {
+                movementX = -absValue;
+            } else if (this.config.isRightButton(axis, false, (value > 0 ? 1 : 2))) {
+                movementX = absValue;
+            }
+
+            if (client.currentScreen != null && allowMouseControl) {
+                boolean moving = Math.abs(movementY) >= deadZone || Math.abs(movementX) >= deadZone;
+                if (moving) {
+                /*
+                    Updates the target mouse position when the initial movement stick movement is detected.
+                    It prevents the cursor to jump to the old target mouse position if the user moves the cursor with the mouse.
+                 */
+                    if (Math.abs(prevXAxis) < deadZone && Math.abs(prevYAxis) < deadZone) {
+                        INPUT_MANAGER.resetMouseTarget(client);
+                    }
+
+                    if (Math.abs(movementX) >= deadZone)
+                        this.mouseSpeedX = movementX;
+                    else
+                        this.mouseSpeedX = 0.F;
+
+                    if (Math.abs(movementY) >= deadZone)
+                        this.mouseSpeedY = movementY;
+                    else
+                        this.mouseSpeedY = 0.F;
+                } else {
+                    this.mouseSpeedX = 0.F;
+                    this.mouseSpeedY = 0.F;
+                }
+
+                if (Math.abs(this.mouseSpeedX) >= .05F || Math.abs(this.mouseSpeedY) >= .05F) {
+                    InputManager.queueMoveMousePosition(this.mouseSpeedX * this.config.getMouseSpeed(), this.mouseSpeedY * this.config.getMouseSpeed());
+                }
+
+                this.moveMouseToClosestSlot(client, client.currentScreen);
+            }
+
+            this.prevXAxis = movementX;
+            this.prevYAxis = movementY;
+        }
+    }
+
+    private boolean handleAButton(@NotNull Screen screen, @NotNull Element focused)
+    {
+        if (focused instanceof AbstractPressableButtonWidget) {
+            AbstractPressableButtonWidget widget = (AbstractPressableButtonWidget) focused;
+            widget.playDownSound(MinecraftClient.getInstance().getSoundManager());
+            widget.onPress();
+            return true;
+        } else if (focused instanceof SpruceLabelWidget) {
+            ((SpruceLabelWidget) focused).onPress();
+            return true;
+        } else if (focused instanceof WorldListWidget) {
+            WorldListWidget list = (WorldListWidget) focused;
+            list.method_20159().ifPresent(WorldListWidget.Entry::play);
+            return true;
+        } else if (focused instanceof MultiplayerServerListWidget) {
+            MultiplayerServerListWidget list = (MultiplayerServerListWidget) focused;
+            MultiplayerServerListWidget.Entry entry = list.getSelected();
+            if (entry instanceof MultiplayerServerListWidget.LanServerEntry || entry instanceof MultiplayerServerListWidget.ServerEntry) {
+                ((MultiplayerScreen) screen).select(entry);
+                ((MultiplayerScreen) screen).connect();
+            }
+        } else if (focused instanceof ParentElement) {
+            Element childFocused = ((ParentElement) focused).getFocused();
+            if (childFocused != null)
+                return this.handleAButton(screen, childFocused);
+        }
+        return false;
+    }
+
+    /**
+     * Handles the left and right buttons.
+     *
+     * @param screen The current screen.
+     * @param right  True if the right button is pressed, else false.
+     */
+    private boolean handleLeftRight(@NotNull Screen screen, boolean right)
+    {
+        Element focused = screen.getFocused();
+        if (focused != null)
+            if (this.handleRightLeftElement(focused, right))
+                return this.changeFocus(screen, right);
+        return true;
+    }
+
+    private boolean handleRightLeftElement(@NotNull Element element, boolean right)
+    {
+        if (element instanceof SliderWidget) {
+            SliderWidget slider = (SliderWidget) element;
+            slider.keyPressed(right ? 262 : 263, 0, 0);
+            this.actionGuiCooldown = 2; // Prevent to press too quickly the focused element, so we have to skip 5 ticks.
+            return false;
+        } else if (element instanceof AlwaysSelectedEntryListWidget) {
+            ((EntryListWidgetAccessor) element).lambdacontrols_moveSelection(right ? EntryListWidget.MoveDirection.UP : EntryListWidget.MoveDirection.DOWN);
+            return false;
+        } else if (element instanceof ParentElement) {
+            ParentElement entryList = (ParentElement) element;
+            Element focused = entryList.getFocused();
+            if (focused == null)
+                return true;
+            return this.handleRightLeftElement(focused, right);
+        }
+        return true;
+    }
+
+    /**
+     * Handles the look direction input.
+     *
+     * @param client The client instance.
+     * @param axis   The axis to change.
+     * @param value  The value of the look.
+     * @param state  The state.
+     */
+    public void handleLook(@NotNull MinecraftClient client, int axis, float value, int state)
+    {
+        // Handles the look direction.
+        if (client.player != null) {
+            double powValue = Math.pow(value, 2.0);
+            if (axis == GLFW_GAMEPAD_AXIS_RIGHT_Y) {
+                if (state == 2) {
+                    this.targetPitch = -this.config.getRightYAxisSign() * (this.config.getRotationSpeed() * powValue) * 0.33D;
+                } else if (state == 1) {
+                    this.targetPitch = this.config.getRightYAxisSign() * (this.config.getRotationSpeed() * powValue) * 0.33D;
+                }
+            }
+            if (axis == GLFW_GAMEPAD_AXIS_RIGHT_X) {
+                if (state == 2) {
+                    this.targetYaw = -this.config.getRightXAxisSign() * (this.config.getRotationSpeed() * powValue) * 0.33D;
+                } else if (state == 1) {
+                    this.targetYaw = this.config.getRightXAxisSign() * (this.config.getRotationSpeed() * powValue) * 0.33D;
+                }
+            }
+        }
+    }
+
+    private boolean changeFocus(@NotNull Screen screen, boolean down)
+    {
+        if (!screen.changeFocus(down)) {
+            if (screen.changeFocus(down)) {
+                this.actionGuiCooldown = 5;
+                return false;
+            }
+            return true;
+        } else {
+            this.actionGuiCooldown = 5;
+            return false;
+        }
+    }
+
+    public static boolean isScreenInteractive(@NotNull Screen screen)
+    {
+        return !(screen instanceof AdvancementsScreen || screen instanceof HandledScreen || screen instanceof ResourcePackScreen || LambdaControlsCompat.requireMouseOnScreen(screen));
+    }
+
+    // Inspired from https://github.com/MrCrayfish/Controllable/blob/1.14.X/src/main/java/com/mrcrayfish/controllable/client/ControllerInput.java#L686.
+    private void moveMouseToClosestSlot(@NotNull MinecraftClient client, @Nullable Screen screen)
+    {
+        // Makes the mouse attracted to slots. This helps with selecting items when using a controller.
+        if (screen instanceof HandledScreen) {
+            HandledScreen inventoryScreen = (HandledScreen) screen;
+            HandledScreenAccessor accessor = (HandledScreenAccessor) inventoryScreen;
+            int guiLeft = accessor.getX();
+            int guiTop = accessor.getY();
+            int mouseX = (int) (targetMouseX * (double) client.getWindow().getScaledWidth() / (double) client.getWindow().getWidth());
+            int mouseY = (int) (targetMouseY * (double) client.getWindow().getScaledHeight() / (double) client.getWindow().getHeight());
+
+            // Finds the closest slot in the GUI within 14 pixels.
+            Optional<Pair<Slot, Double>> closestSlot = inventoryScreen.getScreenHandler().slots.parallelStream()
+                    .map(slot -> {
+                        int x = guiLeft + slot.x + 8;
+                        int y = guiTop + slot.y + 8;
+
+                        // Distance between the slot and the cursor.
+                        double distance = Math.sqrt(Math.pow(x - mouseX, 2) + Math.pow(y - mouseY, 2));
+                        return Pair.of(slot, distance);
+                    }).filter(entry -> entry.value <= 14.0)
+                    .min(Comparator.comparingDouble(p -> p.value));
+
+            if (closestSlot.isPresent()) {
+                Slot slot = closestSlot.get().key;
+                if (slot.hasStack() || !client.player.inventory.getMainHandStack().isEmpty()) {
+                    int slotCenterXScaled = guiLeft + slot.x + 8;
+                    int slotCenterYScaled = guiTop + slot.y + 8;
+                    int slotCenterX = (int) (slotCenterXScaled / ((double) client.getWindow().getScaledWidth() / (double) client.getWindow().getWidth()));
+                    int slotCenterY = (int) (slotCenterYScaled / ((double) client.getWindow().getScaledHeight() / (double) client.getWindow().getHeight()));
+                    double deltaX = slotCenterX - targetMouseX;
+                    double deltaY = slotCenterY - targetMouseY;
+
+                    if (mouseX != slotCenterXScaled || mouseY != slotCenterYScaled) {
+                        this.targetMouseX += deltaX * 0.75;
+                        this.targetMouseY += deltaY * 0.75;
+                    } else {
+                        this.mouseSpeedX *= 0.3F;
+                        this.mouseSpeedY *= 0.3F;
+                    }
+                    this.mouseSpeedX *= .75F;
+                    this.mouseSpeedY *= .75F;
+                } else {
+                    this.mouseSpeedX *= .1F;
+                    this.mouseSpeedY *= .1F;
+                }
+            } else {
+                this.mouseSpeedX *= .3F;
+                this.mouseSpeedY *= .3F;
+            }
+        } else {
+            this.mouseSpeedX = 0.F;
+            this.mouseSpeedY = 0.F;
+        }
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/LambdaReacharound.java

@@ -0,0 +1,164 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client;
+
+import me.lambdaurora.lambdacontrols.LambdaControlsFeature;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.FluidBlock;
+import net.minecraft.block.SlabBlock;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.item.BlockItem;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.hit.BlockHitResult;
+import net.minecraft.util.hit.HitResult;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Direction;
+import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.RayTraceContext;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Represents the reacharound API of LambdaControls.
+ *
+ * @version 1.3.2
+ * @since 1.3.2
+ */
+public class LambdaReacharound
+{
+    private BlockHitResult lastReacharoundResult   = null;
+    private boolean        lastReacharoundVertical = false;
+
+    public void tick(@NotNull MinecraftClient client)
+    {
+        this.lastReacharoundResult = this.tryVerticalReachAround(client);
+        if (this.lastReacharoundResult == null) {
+            this.lastReacharoundResult = this.tryFrontPlace(client);
+            this.lastReacharoundVertical = false;
+        } else this.lastReacharoundVertical = true;
+    }
+
+    /**
+     * Returns the last reach around result.
+     *
+     * @return The last reach around result.
+     */
+    public @Nullable BlockHitResult getLastReacharoundResult()
+    {
+        return this.lastReacharoundResult;
+    }
+
+    /**
+     * Returns whether the last reach around is vertical.
+     *
+     * @return True if the reach around is vertical.
+     */
+    public boolean isLastReacharoundVertical()
+    {
+        return this.lastReacharoundVertical;
+    }
+
+    /**
+     * Returns whether reacharound is available or not.
+     *
+     * @return True if reacharound is available, else false.
+     */
+    public boolean isReacharoundAvailable()
+    {
+        return LambdaControlsFeature.FRONT_BLOCK_PLACING.isAvailable() || LambdaControlsFeature.VERTICAL_REACHAROUND.isAvailable();
+    }
+
+    private float getPlayerRange(@NotNull MinecraftClient client)
+    {
+        return client.interactionManager != null ? client.interactionManager.getReachDistance() : 0.f;
+    }
+
+    /**
+     * Returns a nullable block hit result if vertical reacharound is possible.
+     *
+     * @param client The client instance.
+     * @return A block hit result if vertical reacharound is possible, else null.
+     */
+    public @Nullable BlockHitResult tryVerticalReachAround(@NotNull MinecraftClient client)
+    {
+        if (!LambdaControlsFeature.VERTICAL_REACHAROUND.isAvailable())
+            return null;
+        if (client.player == null || client.world == null || client.crosshairTarget == null || client.crosshairTarget.getType() != HitResult.Type.MISS
+                || !client.player.isOnGround() || client.player.pitch < 80.0F
+                || client.player.isRiding())
+            return null;
+
+        Vec3d pos = client.player.getCameraPosVec(1.0F);
+        Vec3d rotationVec = client.player.getRotationVec(1.0F);
+        float range = getPlayerRange(client);
+        Vec3d rayVec = pos.add(rotationVec.x * range, rotationVec.y * range, rotationVec.z * range).add(0, 0.75, 0);
+        BlockHitResult result = client.world.rayTrace(new RayTraceContext(pos, rayVec, RayTraceContext.ShapeType.OUTLINE, RayTraceContext.FluidHandling.NONE, client.player));
+
+        if (result.getType() == HitResult.Type.BLOCK) {
+            BlockPos blockPos = result.getBlockPos().down();
+            BlockState state = client.world.getBlockState(blockPos);
+
+            if (client.player.getBlockPos().getY() - blockPos.getY() > 1 && (client.world.isAir(blockPos) || state.getMaterial().isReplaceable())) {
+                return new BlockHitResult(result.getPos(), Direction.DOWN, blockPos, false);
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Returns a nullable block hit result if front placing is possible.
+     *
+     * @param client The client instance.
+     * @return A block hit result if front placing is possible.
+     */
+    public @Nullable BlockHitResult tryFrontPlace(@NotNull MinecraftClient client)
+    {
+        if (!LambdaControlsFeature.FRONT_BLOCK_PLACING.isAvailable())
+            return null;
+        if (client.player != null && client.crosshairTarget != null && client.crosshairTarget.getType() == HitResult.Type.MISS && client.player.isOnGround() && client.player.pitch > 35.0F) {
+            if (client.player.isRiding())
+                return null;
+            BlockPos playerPos = client.player.getBlockPos().down();
+            BlockPos targetPos = new BlockPos(client.crosshairTarget.getPos()).subtract(playerPos);
+            BlockPos vector = new BlockPos(MathHelper.clamp(targetPos.getX(), -1, 1), 0, MathHelper.clamp(targetPos.getZ(), -1, 1));
+            BlockPos blockPos = playerPos.add(vector);
+
+            Direction direction = client.player.getHorizontalFacing();
+
+            BlockState state = client.world.getBlockState(blockPos);
+            if (!state.isAir())
+                return null;
+            BlockState adjacentBlockState = client.world.getBlockState(blockPos.offset(direction.getOpposite()));
+            if (adjacentBlockState.isAir() || adjacentBlockState.getBlock() instanceof FluidBlock || (vector.getX() == 0 && vector.getZ() == 0)) {
+                return null;
+            }
+
+            return new BlockHitResult(client.crosshairTarget.getPos(), direction, blockPos, false);
+        }
+        return null;
+    }
+
+    public static @NotNull BlockHitResult withSideForReacharound(@NotNull BlockHitResult result, @Nullable ItemStack stack)
+    {
+        if (stack == null || stack.isEmpty() || !(stack.getItem() instanceof BlockItem))
+            return result;
+        return withSideForReacharound(result, Block.getBlockFromItem(stack.getItem()));
+    }
+
+    public static @NotNull BlockHitResult withSideForReacharound(@NotNull BlockHitResult result, @NotNull Block block)
+    {
+        if (block instanceof SlabBlock)
+            result = result.withSide(Direction.DOWN);
+        return result;
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/VirtualMouseSkin.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client;
+
+import net.minecraft.text.Text;
+import net.minecraft.text.TranslatableText;
+import org.aperlambda.lambdacommon.utils.Nameable;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+/**
+ * Represents the virtual mouse skins.
+ *
+ * @version 1.4.0
+ * @since 1.2.0
+ */
+public enum VirtualMouseSkin implements Nameable
+{
+    DEFAULT_LIGHT("default_light"),
+    DEFAULT_DARK("default_dark"),
+    SECOND_LIGHT("second_light"),
+    SECOND_DARK("second_dark");
+
+    private final String name;
+    private final Text   text;
+
+    VirtualMouseSkin(String name)
+    {
+        this.name = name;
+        this.text = new TranslatableText(this.getTranslationKey());
+    }
+
+    /**
+     * Returns the next virtual mouse skin available.
+     *
+     * @return The next available virtual mouse skin.
+     */
+    public @NotNull VirtualMouseSkin next()
+    {
+        VirtualMouseSkin[] v = values();
+        if (v.length == this.ordinal() + 1)
+            return v[0];
+        return v[this.ordinal() + 1];
+    }
+
+    /**
+     * Returns the translation key of this virtual mouse skin.
+     *
+     * @return The virtual mouse skin's translation key.
+     */
+    public @NotNull String getTranslationKey()
+    {
+        return "lambdacontrols.virtual_mouse.skin." + this.getName();
+    }
+
+    /**
+     * Gets the translated text of this virtual mouse skin.
+     *
+     * @return The translated text of this virtual mouse skin.
+     */
+    public @NotNull Text getTranslatedText()
+    {
+        return this.text;
+    }
+
+    @Override
+    public @NotNull String getName()
+    {
+        return this.name;
+    }
+
+    /**
+     * Gets the virtual mouse skin from its identifier.
+     *
+     * @param id The identifier of the virtual mouse skin.
+     * @return The virtual mouse skin if found, else empty.
+     */
+    public static @NotNull Optional<VirtualMouseSkin> byId(@NotNull String id)
+    {
+        return Arrays.stream(values()).filter(mode -> mode.getName().equalsIgnoreCase(id)).findFirst();
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/compat/CompatHandler.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.compat;
+
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.screen.ingame.HandledScreen;
+import net.minecraft.screen.slot.Slot;
+import net.minecraft.util.hit.BlockHitResult;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Represents a compatibility handler for a mod.
+ *
+ * @author LambdAurora
+ * @version 1.3.2
+ * @since 1.1.0
+ */
+public interface CompatHandler
+{
+    /**
+     * Handles compatibility of a mod.
+     *
+     * @param mod This mod instance.
+     */
+    void handle(@NotNull LambdaControlsClient mod);
+
+    /**
+     * Returns whether the mouse is required on the specified screen.
+     *
+     * @param screen The screen.
+     * @return True if the mouse is required on the specified screen, else false.
+     */
+    default boolean requireMouseOnScreen(Screen screen)
+    {
+        return false;
+    }
+
+    /**
+     * Returns whether the current slot is a creative slot or not.
+     *
+     * @param screen The screen.
+     * @param slot   The slot to check.
+     * @return True if the slot is a creative slot, else false.
+     */
+    default boolean isCreativeSlot(@NotNull HandledScreen screen, @NotNull Slot slot)
+    {
+        return false;
+    }
+
+    /**
+     * Returns a custom translation key to make custom attack action strings on the HUD.
+     *
+     * @param client      The client instance.
+     * @param placeResult The last place block result.
+     * @return Null if untouched, else a translation key.
+     */
+    default String getAttackActionAt(@NotNull MinecraftClient client, @Nullable BlockHitResult placeResult)
+    {
+        return null;
+    }
+
+    /**
+     * Returns a custom translation key to make custom use action strings on the HUD.
+     *
+     * @param client      The client instance.
+     * @param placeResult The last place block result.
+     * @return Null if untouched, else a translation key.
+     */
+    default String getUseActionAt(@NotNull MinecraftClient client, @Nullable BlockHitResult placeResult)
+    {
+        return null;
+    }
+
+    /**
+     * Handles the menu back button.
+     *
+     * @param client The client instance.
+     * @param screen The screen.
+     * @return True if the handle was fired and succeed, else false.
+     */
+    default boolean handleMenuBack(@NotNull MinecraftClient client, @NotNull Screen screen)
+    {
+        return false;
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/compat/HQMCompat.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.compat;
+
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import net.minecraft.client.gui.screen.Screen;
+import org.aperlambda.lambdacommon.utils.LambdaReflection;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Optional;
+
+/**
+ * Represents HQM compatibility handler.
+ * <p>
+ * This is bad.
+ *
+ * @author LambdAurora
+ * @version 1.3.2
+ * @since 1.3.2
+ */
+public class HQMCompat implements CompatHandler
+{
+    public static final String             GUI_BASE_CLASS_PATH = "hardcorequesting.client.interfaces.GuiBase";
+    private             Optional<Class<?>> guiBaseClass;
+
+    @Override
+    public void handle(@NotNull LambdaControlsClient mod)
+    {
+        this.guiBaseClass = LambdaReflection.getClass(GUI_BASE_CLASS_PATH);
+    }
+
+    @Override
+    public boolean requireMouseOnScreen(Screen screen)
+    {
+        return this.guiBaseClass.map(clazz -> clazz.isInstance(screen)).orElse(false);
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/compat/LambdaControlsCompat.java

@@ -0,0 +1,152 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.compat;
+
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import me.lambdaurora.lambdacontrols.client.controller.InputManager;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.util.hit.BlockHitResult;
+import org.aperlambda.lambdacommon.utils.LambdaReflection;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
+
+/**
+ * Represents a compatibility handler.
+ *
+ * @author LambdAurora
+ * @version 1.3.2
+ * @since 1.1.0
+ */
+public class LambdaControlsCompat
+{
+    private static final List<CompatHandler> HANDLERS = new ArrayList<>();
+
+    /**
+     * Initializes compatibility with other mods if needed.
+     *
+     * @param mod The mod instance.
+     */
+    public static void init(@NotNull LambdaControlsClient mod)
+    {
+        if (FabricLoader.getInstance().isModLoaded("okzoomer")) {
+            mod.log("Adding okzoomer compatibility...");
+            HANDLERS.add(new OkZoomerCompat());
+        }
+        if (isReiPresent()) {
+            mod.log("Adding REI compatiblity...");
+            HANDLERS.add(new ReiCompat());
+        }
+        if (FabricLoader.getInstance().isModLoaded("hardcorequesting") && LambdaReflection.doesClassExist(HQMCompat.GUI_BASE_CLASS_PATH)) {
+            mod.log("Adding HQM compatibility...");
+            HANDLERS.add(new HQMCompat());
+        }
+        HANDLERS.forEach(handler -> handler.handle(mod));
+        InputManager.loadButtonBindings(mod.config);
+    }
+
+    /**
+     * Registers a new compatibility handler.
+     *
+     * @param handler The compatibility handler to register.
+     */
+    public static void registerCompatHandler(@NotNull CompatHandler handler)
+    {
+        HANDLERS.add(handler);
+    }
+
+    /**
+     * Streams through compatibility handlers.
+     *
+     * @return A stream of compatibility handlers.
+     */
+    public static Stream<CompatHandler> streamCompatHandlers()
+    {
+        return HANDLERS.stream();
+    }
+
+    /**
+     * Returns whether the mouse is required on the specified screen.
+     *
+     * @param screen The screen.
+     * @return True if the mouse is requried on the specified screen, else false.
+     */
+    public static boolean requireMouseOnScreen(Screen screen)
+    {
+        return HANDLERS.stream().anyMatch(handler -> handler.requireMouseOnScreen(screen));
+    }
+
+    /**
+     * Returns a custom translation key to make custom attack action strings on the HUD.
+     *
+     * @param client      The client instance.
+     * @param placeResult The last place block result.
+     * @return Null if untouched, else a translation key.
+     */
+    public static String getAttackActionAt(@NotNull MinecraftClient client, @Nullable BlockHitResult placeResult)
+    {
+        for (CompatHandler handler : HANDLERS) {
+            String action = handler.getAttackActionAt(client, placeResult);
+            if (action != null) {
+                return action;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Returns a custom translation key to make custom use action strings on the HUD.
+     *
+     * @param client      The client instance.
+     * @param placeResult The last place block result.
+     * @return Null if untouched, else a translation key.
+     */
+    public static String getUseActionAt(@NotNull MinecraftClient client, @Nullable BlockHitResult placeResult)
+    {
+        for (CompatHandler handler : HANDLERS) {
+            String action = handler.getUseActionAt(client, placeResult);
+            if (action != null) {
+                return action;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Handles the menu back button.
+     *
+     * @param client The client instance.
+     * @param screen The screen.
+     * @return True if the handle was fired and succeed, else false.
+     */
+    public static boolean handleMenuBack(@NotNull MinecraftClient client, @NotNull Screen screen)
+    {
+        for (CompatHandler handler : HANDLERS) {
+            if (handler.handleMenuBack(client, screen))
+                return true;
+        }
+        return false;
+    }
+
+    /**
+     * Returns whether Roughly Enough Items is present.
+     *
+     * @return True if Roughly Enough Items is present, else false.
+     */
+    public static boolean isReiPresent()
+    {
+        return FabricLoader.getInstance().isModLoaded("roughlyenoughitems");
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/compat/LambdaControlsMixinPlugin.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.compat;
+
+import org.objectweb.asm.tree.ClassNode;
+import org.spongepowered.asm.mixin.extensibility.IMixinConfigPlugin;
+import org.spongepowered.asm.mixin.extensibility.IMixinInfo;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * This plugin is only present for the conditional mixins.
+ *
+ * @author LambdAurora
+ * @version 1.2.0
+ * @since 1.2.0
+ */
+public class LambdaControlsMixinPlugin implements IMixinConfigPlugin
+{
+    private final HashMap<String, Boolean> conditionalMixins = new HashMap<>();
+
+    public LambdaControlsMixinPlugin()
+    {
+        this.conditionalMixins.put("me.lambdaurora.lambdacontrols.client.compat.mixin.RecipeViewingScreenAccessor", LambdaControlsCompat.isReiPresent());
+        this.conditionalMixins.put("me.lambdaurora.lambdacontrols.client.compat.mixin.VillagerRecipeViewingScreenAccessor", LambdaControlsCompat.isReiPresent());
+    }
+
+    @Override
+    public void onLoad(String mixinPackage)
+    {
+    }
+
+    @Override
+    public String getRefMapperConfig()
+    {
+        return null;
+    }
+
+    @Override
+    public boolean shouldApplyMixin(String targetClassName, String mixinClassName)
+    {
+        return this.conditionalMixins.getOrDefault(mixinClassName, Boolean.TRUE);
+    }
+
+    @Override
+    public void acceptTargets(Set<String> myTargets, Set<String> otherTargets)
+    {
+    }
+
+    @Override
+    public List<String> getMixins()
+    {
+        return null;
+    }
+
+    @Override
+    public void preApply(String targetClassName, ClassNode targetClass, String mixinClassName, IMixinInfo mixinInfo)
+    {
+    }
+
+    @Override
+    public void postApply(String targetClassName, ClassNode targetClass, String mixinClassName, IMixinInfo mixinInfo)
+    {
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/compat/OkZoomerCompat.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.compat;
+
+import io.github.joaoh1.okzoomer.client.OkZoomerClientMod;
+import io.github.joaoh1.okzoomer.main.OkZoomerMod;
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import me.lambdaurora.lambdacontrols.client.controller.ButtonBinding;
+import org.aperlambda.lambdacommon.Identifier;
+import org.jetbrains.annotations.NotNull;
+import org.lwjgl.glfw.GLFW;
+
+/**
+ * Represents a compatibility handler for OkZoomer.
+ *
+ * @author LambdAurora
+ * @version 1.3.0
+ * @since 1.1.0
+ */
+public class OkZoomerCompat implements CompatHandler
+{
+    public static final String OKZOOMER_CLASS_PATH = "io.github.joaoh1.okzoomer.client.OkZoomerClientMod";
+
+    @Override
+    public void handle(@NotNull LambdaControlsClient mod)
+    {
+        new ButtonBinding.Builder("zoom")
+                .buttons(GLFW.GLFW_GAMEPAD_BUTTON_DPAD_UP, GLFW.GLFW_GAMEPAD_BUTTON_X)
+                .onlyInGame()
+                .cooldown(true)
+                .category(ButtonBinding.MISC_CATEGORY)
+                .linkKeybind(OkZoomerClientMod.zoomKeyBinding)
+                .register();
+
+        new ButtonBinding.Builder("zoom.in")
+                .buttons(GLFW.GLFW_GAMEPAD_BUTTON_DPAD_UP, ButtonBinding.axisAsButton(GLFW.GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER, true))
+                .onlyInGame()
+                .cooldown(true)
+                .category(ButtonBinding.MISC_CATEGORY)
+                .linkKeybind(OkZoomerClientMod.increaseZoomKeyBinding)
+                .register();
+        new ButtonBinding.Builder("zoom.out")
+                .buttons(GLFW.GLFW_GAMEPAD_BUTTON_DPAD_UP, ButtonBinding.axisAsButton(GLFW.GLFW_GAMEPAD_AXIS_LEFT_TRIGGER, true))
+                .onlyInGame()
+                .cooldown(true)
+                .category(ButtonBinding.MISC_CATEGORY)
+                .linkKeybind(OkZoomerClientMod.decreaseZoomKeyBinding)
+                .register();
+        new ButtonBinding.Builder("zoom.reset")
+                .onlyInGame()
+                .cooldown(true)
+                .category(ButtonBinding.MISC_CATEGORY)
+                .linkKeybind(OkZoomerClientMod.resetZoomKeyBinding)
+                .register();
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/compat/ReiCompat.java

@@ -0,0 +1,190 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.compat;
+
+import me.lambdaurora.lambdacontrols.client.ButtonState;
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import me.lambdaurora.lambdacontrols.client.compat.mixin.RecipeViewingScreenAccessor;
+import me.lambdaurora.lambdacontrols.client.compat.mixin.VillagerRecipeViewingScreenAccessor;
+import me.lambdaurora.lambdacontrols.client.controller.ButtonBinding;
+import me.lambdaurora.lambdacontrols.client.controller.InputHandlers;
+import me.lambdaurora.lambdacontrols.client.controller.InputManager;
+import me.lambdaurora.lambdacontrols.client.controller.PressAction;
+import me.shedaniel.rei.api.REIHelper;
+import me.shedaniel.rei.api.RecipeCategory;
+import me.shedaniel.rei.gui.ContainerScreenOverlay;
+import me.shedaniel.rei.gui.RecipeViewingScreen;
+import me.shedaniel.rei.gui.VillagerRecipeViewingScreen;
+import me.shedaniel.rei.gui.widget.EntryListWidget;
+import me.shedaniel.rei.impl.ScreenHelper;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.util.Identifier;
+import org.aperlambda.lambdacommon.utils.LambdaReflection;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.Optional;
+
+import static org.lwjgl.glfw.GLFW.*;
+
+/**
+ * Represents a compatibility handler for REI.
+ *
+ * @author LambdAurora
+ * @version 1.4.0
+ * @since 1.2.0
+ */
+public class ReiCompat implements CompatHandler
+{
+    private static EntryListWidget ENTRY_LIST_WIDGET;
+
+    @Override
+    public void handle(@NotNull LambdaControlsClient mod)
+    {
+        InputManager.registerBinding(new ButtonBinding.Builder(new Identifier("rei", "category_back"))
+                .buttons(GLFW_GAMEPAD_BUTTON_LEFT_BUMPER)
+                .filter((client, binding) -> isViewingScreen(client.currentScreen))
+                .action(handleTab(false))
+                .cooldown(true)
+                .build());
+        InputManager.registerBinding(new ButtonBinding.Builder(new Identifier("rei", "category_next"))
+                .buttons(GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER)
+                .filter((client, binding) -> isViewingScreen(client.currentScreen))
+                .action(handleTab(true))
+                .cooldown(true)
+                .build());
+
+        InputManager.registerBinding(new ButtonBinding.Builder(new Identifier("rei", "page_back"))
+                .buttons(ButtonBinding.axisAsButton(GLFW_GAMEPAD_AXIS_RIGHT_X, false))
+                .filter((client, binding) -> InputHandlers.inInventory(client, binding) || isViewingScreen(client.currentScreen))
+                .action(handlePage(false))
+                .cooldown(true)
+                .build());
+        InputManager.registerBinding(new ButtonBinding.Builder(new Identifier("rei", "page_next"))
+                .buttons(ButtonBinding.axisAsButton(GLFW_GAMEPAD_AXIS_RIGHT_X, true))
+                .filter((client, binding) -> InputHandlers.inInventory(client, binding) || isViewingScreen(client.currentScreen))
+                .action(handlePage(true))
+                .cooldown(true)
+                .build());
+
+        // For some reasons this is broken.
+        InputManager.registerBinding(new ButtonBinding.Builder(new Identifier("rei", "show_usage"))
+                .buttons(GLFW_GAMEPAD_BUTTON_RIGHT_THUMB)
+                .filter((client, binding) -> InputHandlers.inInventory(client, binding) || isViewingScreen(client.currentScreen))
+                .action((client, button, value, action) -> {
+                    if (action != ButtonState.RELEASE)
+                        return false;
+                    Optional<ContainerScreenOverlay> overlay = ScreenHelper.getOptionalOverlay();
+                    if (!overlay.isPresent())
+                        return false;
+                    double mouseX = client.mouse.getX();
+                    double mouseY = client.mouse.getY();
+                    EntryListWidget widget = getEntryListWidget();
+                    if (widget == null)
+                        return false;
+                    return widget.mouseClicked(mouseX, mouseY, GLFW_MOUSE_BUTTON_2);
+                })
+                .cooldown(true)
+                .build());
+    }
+
+    @Override
+    public boolean requireMouseOnScreen(Screen screen)
+    {
+        return isViewingScreen(screen);
+    }
+
+    private static boolean isViewingScreen(Screen screen)
+    {
+        return screen instanceof RecipeViewingScreen || screen instanceof VillagerRecipeViewingScreen;
+    }
+
+    @Override
+    public boolean handleMenuBack(@NotNull MinecraftClient client, @NotNull Screen screen)
+    {
+        if (!isViewingScreen(screen))
+            return false;
+
+        MinecraftClient.getInstance().openScreen(REIHelper.getInstance().getPreviousContainerScreen());
+        ScreenHelper.getLastOverlay().init();
+        return true;
+    }
+
+    private static EntryListWidget getEntryListWidget()
+    {
+        if (ENTRY_LIST_WIDGET == null) {
+            ENTRY_LIST_WIDGET = LambdaReflection.getFirstFieldOfType(ContainerScreenOverlay.class, EntryListWidget.class)
+                    .map(field -> (EntryListWidget) LambdaReflection.getFieldValue(null, field))
+                    .orElse(null);
+        }
+        return ENTRY_LIST_WIDGET;
+    }
+
+    private static PressAction handlePage(boolean next)
+    {
+        return (client, button, value, action) -> {
+            if (action == ButtonState.RELEASE)
+                return false;
+
+            Optional<ContainerScreenOverlay> overlay = ScreenHelper.getOptionalOverlay();
+            if (!overlay.isPresent())
+                return false;
+
+            EntryListWidget widget = getEntryListWidget();
+            if (widget == null)
+                return false;
+
+            if (next)
+                widget.nextPage();
+            else
+                widget.previousPage();
+            widget.updateEntriesPosition();
+
+            return true;
+        };
+    }
+
+    /**
+     * Returns the handler for category tabs buttons.
+     *
+     * @param next True if the action is to switch to the next tab.
+     * @return The handler.
+     */
+    private static PressAction handleTab(boolean next)
+    {
+        return (client, button, value, action) -> {
+            if (action != ButtonState.RELEASE)
+                return false;
+
+            if (client.currentScreen instanceof RecipeViewingScreen) {
+                RecipeViewingScreenAccessor screen = (RecipeViewingScreenAccessor) client.currentScreen;
+                if (next)
+                    screen.getCategoryNext().onClick();
+                else
+                    screen.getCategoryBack().onClick();
+                return true;
+            } else if (client.currentScreen instanceof VillagerRecipeViewingScreen) {
+                VillagerRecipeViewingScreenAccessor screen = (VillagerRecipeViewingScreenAccessor) client.currentScreen;
+                List<RecipeCategory<?>> categories = screen.getCategories();
+                int currentTab = screen.getSelectedCategoryIndex();
+                int nextTab = currentTab + (next ? 1 : -1);
+                if (nextTab < 0)
+                    nextTab = categories.size() - 1;
+                else if (nextTab >= categories.size())
+                    nextTab = 0;
+                screen.setSelectedCategoryIndex(nextTab);
+                screen.lambdacontrols_init();
+                return true;
+            }
+            return false;
+        };
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/compat/mixin/RecipeViewingScreenAccessor.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.compat.mixin;
+
+import me.shedaniel.rei.api.widgets.Button;
+import me.shedaniel.rei.gui.RecipeViewingScreen;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+/**
+ * Represents an accessor to REI's RecipeViewingScreen.
+ *
+ * @author LambdAurora
+ * @version 1.4.0
+ * @since 1.2.0
+ */
+@Mixin(value = RecipeViewingScreen.class, remap = false)
+public interface RecipeViewingScreenAccessor
+{
+    @Accessor("categoryBack")
+    Button getCategoryBack();
+
+    @Accessor("categoryNext")
+    Button getCategoryNext();
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/compat/mixin/VillagerRecipeViewingScreenAccessor.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.compat.mixin;
+
+import me.shedaniel.rei.api.RecipeCategory;
+import me.shedaniel.rei.gui.VillagerRecipeViewingScreen;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+import java.util.List;
+
+/**
+ * Represents an accessor to REI's VillagerRecipeViewingScreen.
+ *
+ * @author LambdAurora
+ * @version 1.4.1
+ * @since 1.2.0
+ */
+@Mixin(VillagerRecipeViewingScreen.class)
+public interface VillagerRecipeViewingScreenAccessor
+{
+    @Accessor(value = "categories", remap = false)
+    List<RecipeCategory<?>> getCategories();
+
+    @Accessor(value = "selectedCategoryIndex", remap = false)
+    int getSelectedCategoryIndex();
+
+    @Accessor(value = "selectedCategoryIndex", remap = false)
+    void setSelectedCategoryIndex(int selectedCategoryIndex);
+
+    @Invoker("init")
+    void lambdacontrols_init();
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/controller/ButtonBinding.java

@@ -0,0 +1,611 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.controller;
+
+import me.lambdaurora.lambdacontrols.client.ButtonState;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.options.GameOptions;
+import net.minecraft.client.options.KeyBinding;
+import net.minecraft.text.Text;
+import net.minecraft.text.TranslatableText;
+import org.aperlambda.lambdacommon.Identifier;
+import org.aperlambda.lambdacommon.utils.Nameable;
+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 me.lambdaurora.lambdacontrols.client.controller.InputManager.registerDefaultCategory;
+import static org.lwjgl.glfw.GLFW.*;
+
+/**
+ * Represents a button binding.
+ *
+ * @author LambdAurora
+ * @version 1.4.0
+ * @since 1.0.0
+ */
+public class ButtonBinding implements Nameable
+{
+    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(true).register();
+    public static final ButtonBinding DROP_ITEM          = new Builder("drop_item").buttons(GLFW_GAMEPAD_BUTTON_B).onlyInGame().cooldown(true).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(true).register();
+    public static final ButtonBinding HOTBAR_RIGHT       = new Builder("hotbar_right").buttons(GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER)
+            .action(InputHandlers.handleHotbar(true)).onlyInGame().cooldown(true).register();
+    public static final ButtonBinding INVENTORY          = new Builder("inventory").buttons(GLFW_GAMEPAD_BUTTON_Y).onlyInGame().cooldown(true).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(true).register();
+    public static final ButtonBinding PICK_BLOCK         = new Builder("pick_block").buttons(GLFW_GAMEPAD_BUTTON_DPAD_LEFT).onlyInGame().cooldown(true).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).register();
+    public static final ButtonBinding SCREENSHOT         = new Builder("screenshot").buttons(GLFW_GAMEPAD_BUTTON_DPAD_UP, GLFW_GAMEPAD_BUTTON_A)
+            .action(InputHandlers::handleScreenshot).cooldown(true).register();
+    public static final ButtonBinding SLOT_DOWN          = new Builder("slot_down").buttons(GLFW_GAMEPAD_BUTTON_DPAD_DOWN)
+            .action(InputHandlers.handleInventorySlotPad(1)).onlyInInventory().cooldown(true).register();
+    public static final ButtonBinding SLOT_LEFT          = new Builder("slot_left").buttons(GLFW_GAMEPAD_BUTTON_DPAD_LEFT)
+            .action(InputHandlers.handleInventorySlotPad(3)).onlyInInventory().cooldown(true).register();
+    public static final ButtonBinding SLOT_RIGHT         = new Builder("slot_right").buttons(GLFW_GAMEPAD_BUTTON_DPAD_RIGHT)
+            .action(InputHandlers.handleInventorySlotPad(2)).onlyInInventory().cooldown(true).register();
+    public static final ButtonBinding SLOT_UP            = new Builder("slot_up").buttons(GLFW_GAMEPAD_BUTTON_DPAD_UP)
+            .action(InputHandlers.handleInventorySlotPad(0)).onlyInInventory().cooldown(true).register();
+    public static final ButtonBinding SMOOTH_CAMERA      = new Builder("toggle_smooth_camera").cooldown(true).register();
+    public static final ButtonBinding SNEAK              = new Builder("sneak").buttons(GLFW_GAMEPAD_BUTTON_RIGHT_THUMB)
+            .actions(PressAction.DEFAULT_ACTION, InputHandlers::handleToggleSneak).onlyInGame().cooldown(true).register();
+    public static final ButtonBinding SPRINT             = new Builder("sprint").buttons(GLFW_GAMEPAD_BUTTON_LEFT_THUMB).register();
+    public static final ButtonBinding SWAP_HANDS         = new Builder("swap_hands").buttons(GLFW_GAMEPAD_BUTTON_X).cooldown(true).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(true).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(true).register();
+    public static final ButtonBinding TOGGLE_PERSPECTIVE = new Builder("toggle_perspective").buttons(GLFW_GAMEPAD_BUTTON_DPAD_UP, GLFW_GAMEPAD_BUTTON_Y).cooldown(true).register();
+    public static final ButtonBinding USE                = new Builder("use").buttons(axisAsButton(GLFW_GAMEPAD_AXIS_LEFT_TRIGGER, true)).register();
+
+    private   int[]                                         button;
+    private   int[]                                         defaultButton;
+    private   String                                        key;
+    private   KeyBinding                                    mcKeyBinding = null;
+    protected PairPredicate<MinecraftClient, ButtonBinding> filter;
+    private   List<PressAction>                             actions      = new ArrayList<>(Collections.singletonList(PressAction.DEFAULT_ACTION));
+    private   boolean                                       hasCooldown;
+    private   int                                           cooldown     = 0;
+    boolean pressed = false;
+
+    public ButtonBinding(@NotNull String key, int[] defaultButton, @NotNull List<PressAction> actions, PairPredicate<MinecraftClient, ButtonBinding> filter, boolean hasCooldown)
+    {
+        this.setButton(this.defaultButton = defaultButton);
+        this.key = key;
+        this.filter = filter;
+        this.actions.addAll(actions);
+        this.hasCooldown = hasCooldown;
+    }
+
+    public ButtonBinding(@NotNull 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 @NotNull
+    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;
+        }
+    }
+
+    @Override
+    public @NotNull String getName()
+    {
+        return this.key;
+    }
+
+    /**
+     * Returns the translation key of this button binding.
+     *
+     * @return The translation key.
+     */
+    public @NotNull String getTranslationKey()
+    {
+        return "lambdacontrols.action." + this.getName();
+    }
+
+    /**
+     * Returns the key binding equivalent of this button binding.
+     *
+     * @return The key binding equivalent.
+     */
+    public @NotNull
+    Optional<KeyBinding> asKeyBinding()
+    {
+        return Optional.ofNullable(this.mcKeyBinding);
+    }
+
+    /**
+     * 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)
+    {
+        switch (button % 500) {
+            case -1:
+                return new TranslatableText("key.keyboard.unknown");
+            case GLFW_GAMEPAD_BUTTON_A:
+                return new TranslatableText("lambdacontrols.button.a");
+            case GLFW_GAMEPAD_BUTTON_B:
+                return new TranslatableText("lambdacontrols.button.b");
+            case GLFW_GAMEPAD_BUTTON_X:
+                return new TranslatableText("lambdacontrols.button.x");
+            case GLFW_GAMEPAD_BUTTON_Y:
+                return new TranslatableText("lambdacontrols.button.y");
+            case GLFW_GAMEPAD_BUTTON_LEFT_BUMPER:
+                return new TranslatableText("lambdacontrols.button.left_bumper");
+            case GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER:
+                return new TranslatableText("lambdacontrols.button.right_bumper");
+            case GLFW_GAMEPAD_BUTTON_BACK:
+                return new TranslatableText("lambdacontrols.button.back");
+            case GLFW_GAMEPAD_BUTTON_START:
+                return new TranslatableText("lambdacontrols.button.start");
+            case GLFW_GAMEPAD_BUTTON_GUIDE:
+                return new TranslatableText("lambdacontrols.button.guide");
+            case GLFW_GAMEPAD_BUTTON_LEFT_THUMB:
+                return new TranslatableText("lambdacontrols.button.left_thumb");
+            case GLFW_GAMEPAD_BUTTON_RIGHT_THUMB:
+                return new TranslatableText("lambdacontrols.button.right_thumb");
+            case GLFW_GAMEPAD_BUTTON_DPAD_UP:
+                return new TranslatableText("lambdacontrols.button.dpad_up");
+            case GLFW_GAMEPAD_BUTTON_DPAD_RIGHT:
+                return new TranslatableText("lambdacontrols.button.dpad_right");
+            case GLFW_GAMEPAD_BUTTON_DPAD_DOWN:
+                return new TranslatableText("lambdacontrols.button.dpad_down");
+            case GLFW_GAMEPAD_BUTTON_DPAD_LEFT:
+                return new TranslatableText("lambdacontrols.button.dpad_left");
+            case 100:
+                return new TranslatableText("lambdacontrols.axis.left_x+");
+            case 101:
+                return new TranslatableText("lambdacontrols.axis.left_y+");
+            case 102:
+                return new TranslatableText("lambdacontrols.axis.right_x+");
+            case 103:
+                return new TranslatableText("lambdacontrols.axis.right_y+");
+            case 104:
+                return new TranslatableText("lambdacontrols.axis.left_trigger");
+            case 105:
+                return new TranslatableText("lambdacontrols.axis.right_trigger");
+            case 200:
+                return new TranslatableText("lambdacontrols.axis.left_x-");
+            case 201:
+                return new TranslatableText("lambdacontrols.axis.left_y-");
+            case 202:
+                return new TranslatableText("lambdacontrols.axis.right_x-");
+            case 203:
+                return new TranslatableText("lambdacontrols.axis.right_y-");
+            default:
+                return new TranslatableText("lambdacontrols.button.unknown", button);
+        }
+    }
+
+    static {
+        MOVEMENT_CATEGORY = registerDefaultCategory("key.categories.movement", category -> category.registerAllBindings(
+                ButtonBinding.FORWARD,
+                ButtonBinding.BACK,
+                ButtonBinding.LEFT,
+                ButtonBinding.RIGHT,
+                ButtonBinding.JUMP,
+                ButtonBinding.SNEAK,
+                ButtonBinding.SPRINT));
+        GAMEPLAY_CATEGORY = registerDefaultCategory("key.categories.gameplay", category -> category.registerAllBindings(
+                ButtonBinding.ATTACK,
+                ButtonBinding.PICK_BLOCK,
+                ButtonBinding.USE
+        ));
+        INVENTORY_CATEGORY = registerDefaultCategory("key.categories.inventory", category -> category.registerAllBindings(
+                ButtonBinding.DROP_ITEM,
+                ButtonBinding.HOTBAR_LEFT,
+                ButtonBinding.HOTBAR_RIGHT,
+                ButtonBinding.INVENTORY,
+                ButtonBinding.SWAP_HANDS
+        ));
+        MULTIPLAYER_CATEGORY = registerDefaultCategory("key.categories.multiplayer",
+                category -> category.registerAllBindings(ButtonBinding.CHAT, ButtonBinding.PLAYER_LIST));
+        MISC_CATEGORY = registerDefaultCategory("key.categories.misc", category -> category.registerAllBindings(
+                ButtonBinding.SCREENSHOT,
+                //SMOOTH_CAMERA,
+                ButtonBinding.TOGGLE_PERSPECTIVE
+        ));
+    }
+
+    /**
+     * Represents a quick {@link ButtonBinding} builder.
+     *
+     * @author LambdAurora
+     * @version 1.1.0
+     * @since 1.1.0
+     */
+    public static class Builder
+    {
+        private final String                                        key;
+        private       int[]                                         buttons   = new int[0];
+        private       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.getName());
+        }
+
+        public Builder(@NotNull net.minecraft.util.Identifier identifier)
+        {
+            this(new Identifier(identifier.toString()));
+        }
+
+        /**
+         * 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;
+        }
+
+        /**
+         * 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()
+        {
+            ButtonBinding 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());
+        }
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/controller/ButtonCategory.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.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       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;
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/controller/Controller.java

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2019 LambdAurora <aurora42lambda@gmail.com>
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
  *
  * This file is part of LambdaControls.
  *
@@ -7,8 +7,9 @@
  * see the LICENSE file.
  */
 
-package me.lambdaurora.lambdacontrols;
+package me.lambdaurora.lambdacontrols.client.controller;
 
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
 import org.aperlambda.lambdacommon.utils.Nameable;
 import org.jetbrains.annotations.NotNull;
 import org.lwjgl.glfw.GLFW;
@@ -31,6 +32,10 @@ import static org.lwjgl.BufferUtils.createByteBuffer;
 
 /**
  * Represents a controller.
+ *
+ * @author LambdAurora
+ * @version 1.0.0
+ * @since 1.0.0
  */
 public class Controller implements Nameable
 {
@@ -47,7 +52,7 @@ public class Controller implements Nameable
      *
      * @return The identifier of this controller.
      */
-    public int get_id()
+    public int getId()
     {
         return this.id;
     }
@@ -57,7 +62,7 @@ public class Controller implements Nameable
      *
      * @return The controller's GUID.
      */
-    public String get_guid()
+    public String getGuid()
     {
         String guid = GLFW.glfwGetJoystickGUID(this.id);
         return guid == null ? "" : guid;
@@ -68,7 +73,7 @@ public class Controller implements Nameable
      *
      * @return True if this controller is connected, else false.
      */
-    public boolean is_connected()
+    public boolean isConnected()
     {
         return GLFW.glfwJoystickPresent(this.id);
     }
@@ -78,9 +83,9 @@ public class Controller implements Nameable
      *
      * @return True if this controller is a gamepad, else false.
      */
-    public boolean is_gamepad()
+    public boolean isGamepad()
     {
-        return this.is_connected() && GLFW.glfwJoystickIsGamepad(this.id);
+        return this.isConnected() && GLFW.glfwJoystickIsGamepad(this.id);
     }
 
     /**
@@ -89,10 +94,10 @@ public class Controller implements Nameable
      * @return The controller's name.
      */
     @Override
-    public @NotNull String get_name()
+    public @NotNull String getName()
     {
-        String name = this.is_gamepad() ? GLFW.glfwGetGamepadName(this.id) : GLFW.glfwGetJoystickName(this.id);
-        return name == null ? String.valueOf(this.get_id()) : name;
+        String name = this.isGamepad() ? GLFW.glfwGetGamepadName(this.id) : GLFW.glfwGetJoystickName(this.id);
+        return name == null ? String.valueOf(this.getId()) : name;
     }
 
     /**
@@ -100,18 +105,18 @@ public class Controller implements Nameable
      *
      * @return The state of the controller input.
      */
-    public GLFWGamepadState get_state()
+    public GLFWGamepadState getState()
     {
         GLFWGamepadState state = GLFWGamepadState.create();
-        if (this.is_gamepad())
+        if (this.isGamepad())
             GLFW.glfwGetGamepadState(this.id, state);
         return state;
     }
 
-    public static @NotNull Controller by_id(int id)
+    public static @NotNull Controller byId(int id)
     {
         if (id > GLFW.GLFW_JOYSTICK_LAST) {
-            LambdaControls.get().log("Controller '" + id + "' doesn't exist.");
+            LambdaControlsClient.get().log("Controller '" + id + "' doesn't exist.");
             id = GLFW.GLFW_JOYSTICK_LAST;
         }
         Controller controller;
@@ -124,22 +129,22 @@ public class Controller implements Nameable
         }
     }
 
-    public static @NotNull Optional<Controller> by_guid(@NotNull String guid)
+    public static @NotNull Optional<Controller> byGuid(@NotNull String guid)
     {
-        return CONTROLLERS.values().stream().filter(Controller::is_connected)
-                .filter(controller -> controller.get_guid().equals(guid))
-                .max(Comparator.comparingInt(Controller::get_id));
+        return CONTROLLERS.values().stream().filter(Controller::isConnected)
+                .filter(controller -> controller.getGuid().equals(guid))
+                .max(Comparator.comparingInt(Controller::getId));
     }
 
     /**
      * Reads the specified resource and returns the raw data as a ByteBuffer.
      *
-     * @param resource    The resource to read.
-     * @param buffer_size The initial buffer size.
+     * @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 io_resource_to_buffer(String resource, int buffer_size) throws IOException
+    private static ByteBuffer ioResourceToBuffer(String resource, int bufferSize) throws IOException
     {
         ByteBuffer buffer = null;
 
@@ -159,14 +164,14 @@ public class Controller implements Nameable
     /**
      * Updates the controller mappings.
      */
-    public static void update_mappings()
+    public static void updateMappings()
     {
         try {
-            File mappings_file = new File("config/gamecontrollerdb.txt");
-            if (!mappings_file.exists())
+            File mappingsFile = new File("config/gamecontrollerdb.txt");
+            if (!mappingsFile.exists())
                 return;
-            LambdaControls.get().log("Updating controller mappings...");
-            ByteBuffer buffer = io_resource_to_buffer(mappings_file.getPath(), 1024);
+            LambdaControlsClient.get().log("Updating controller mappings...");
+            ByteBuffer buffer = ioResourceToBuffer(mappingsFile.getPath(), 1024);
             GLFW.glfwUpdateGamepadMappings(buffer);
         } catch (IOException e) {
             e.printStackTrace();

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/controller/InputHandlers.java

@@ -0,0 +1,282 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.controller;
+
+import me.lambdaurora.lambdacontrols.client.ButtonState;
+import me.lambdaurora.lambdacontrols.client.LambdaInput;
+import me.lambdaurora.lambdacontrols.client.mixin.AdvancementsScreenAccessor;
+import me.lambdaurora.lambdacontrols.client.mixin.CreativeInventoryScreenAccessor;
+import me.lambdaurora.lambdacontrols.client.mixin.RecipeBookWidgetAccessor;
+import me.lambdaurora.lambdacontrols.client.util.HandledScreenAccessor;
+import me.lambdaurora.lambdacontrols.client.util.KeyBindingAccessor;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.screen.advancement.AdvancementTab;
+import net.minecraft.client.gui.screen.advancement.AdvancementsScreen;
+import net.minecraft.client.gui.screen.ingame.CreativeInventoryScreen;
+import net.minecraft.client.gui.screen.ingame.HandledScreen;
+import net.minecraft.client.gui.screen.ingame.InventoryScreen;
+import net.minecraft.client.gui.screen.recipebook.RecipeGroupButtonWidget;
+import net.minecraft.client.util.ScreenshotUtils;
+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.List;
+import java.util.Optional;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+/**
+ * Represents some input handlers.
+ *
+ * @author LambdAurora
+ * @version 1.4.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.inventory.selectedSlot = client.player.inventory.selectedSlot == 8 ? 0 : client.player.inventory.selectedSlot + 1;
+                else
+                    client.player.inventory.selectedSlot = client.player.inventory.selectedSlot == 0 ? 8 : client.player.inventory.selectedSlot - 1;
+                return true;
+            } else if (client.currentScreen instanceof CreativeInventoryScreen) {
+                CreativeInventoryScreenAccessor inventory = (CreativeInventoryScreenAccessor) client.currentScreen;
+                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.lambdacontrols_setSelectedTab(ItemGroup.GROUPS[nextTab]);
+                return true;
+            } else if (client.currentScreen instanceof InventoryScreen) {
+                RecipeBookWidgetAccessor recipeBook = (RecipeBookWidgetAccessor) ((InventoryScreen) client.currentScreen).getRecipeBookWidget();
+                List<RecipeGroupButtonWidget> tabs = recipeBook.getTabButtons();
+                RecipeGroupButtonWidget 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.lambdacontrols_refreshResults(true);
+                return true;
+            } else if (client.currentScreen instanceof AdvancementsScreen) {
+                AdvancementsScreenAccessor screen = (AdvancementsScreenAccessor) client.currentScreen;
+                List<AdvancementTab> tabs = screen.getTabs().values().stream().distinct().collect(Collectors.toList());
+                AdvancementTab 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)
+            ScreenshotUtils.saveScreenshot(client.runDirectory, client.getWindow().getFramebufferWidth(), client.getWindow().getFramebufferHeight(), 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)
+    {
+        if (client.player != null && !client.player.abilities.flying) {
+            button.asKeyBinding().filter(binding -> action == ButtonState.PRESS).ifPresent(binding -> ((KeyBindingAccessor) binding).lambdacontrols_handlePressState(!binding.isPressed()));
+            return true;
+        }
+        return false;
+    }
+
+    public static PressAction handleInventorySlotPad(int direction)
+    {
+        return (client, binding, value, action) -> {
+            if (!(client.currentScreen instanceof HandledScreen && action != ButtonState.RELEASE))
+                return false;
+
+            HandledScreen inventory = (HandledScreen) client.currentScreen;
+            HandledScreenAccessor 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.
+            Slot mouseSlot = accessor.lambdacontrols_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 -> {
+                        Slot 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()) {
+                Slot 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 !LambdaInput.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;
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/controller/InputManager.java

@@ -0,0 +1,415 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.controller;
+
+import me.lambdaurora.lambdacontrols.ControlsMode;
+import me.lambdaurora.lambdacontrols.client.ButtonState;
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import me.lambdaurora.lambdacontrols.client.LambdaControlsConfig;
+import me.lambdaurora.lambdacontrols.client.util.MouseAccessor;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.options.KeyBinding;
+import net.minecraft.client.util.InputUtil;
+import net.minecraft.util.math.MathHelper;
+import org.aperlambda.lambdacommon.Identifier;
+import org.aperlambda.lambdacommon.utils.Pair;
+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.4.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  Map<Integer, ButtonState> STATES           = new HashMap<>();
+    public static final  Map<Integer, Float>       BUTTON_VALUES    = new HashMap<>();
+    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 (LambdaControlsClient.get().config.getControlsMode() == 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 (!LambdaControlsClient.get().config.hasVirtualMouse())
+                GLFW.glfwSetCursorPos(client.getWindow().getHandle(), mouseX, mouseY);
+            ((MouseAccessor) client.mouse).lambdacontrols_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) {
+            List<ButtonBinding> sorted = BINDINGS.stream().sorted(Collections.reverseOrder(Comparator.comparingInt(binding -> binding.getButton().length)))
+                    .collect(Collectors.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)
+    {
+        ButtonCategory category = registerCategory(new Identifier("minecraft", key), CATEGORIES.size());
+        keyAdder.accept(category);
+        return category;
+    }
+
+    /**
+     * Loads the button bindings from configuration.
+     *
+     * @param config The configuration instance.
+     */
+    public static void loadButtonBindings(@NotNull LambdaControlsConfig config)
+    {
+        List<ButtonBinding> queue = new ArrayList<>(BINDINGS);
+        queue.forEach(config::loadButtonBinding);
+    }
+
+    /**
+     * Returns the binding state.
+     *
+     * @param binding The binding.
+     * @return The current state of the binding.
+     */
+    public static @NotNull ButtonState getBindingState(@NotNull ButtonBinding binding)
+    {
+        ButtonState state = ButtonState.REPEAT;
+        for (int btn : binding.getButton()) {
+            ButtonState 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()
+    {
+        STATES.forEach((btn, state) -> {
+            if (state == ButtonState.PRESS)
+                STATES.put(btn, ButtonState.REPEAT);
+            else if (state == ButtonState.RELEASE)
+                STATES.put(btn, ButtonState.NONE);
+        });
+    }
+
+    public static void updateBindings(@NotNull MinecraftClient client)
+    {
+        List<Integer> skipButtons = new ArrayList<>();
+        Map<ButtonBinding, Pair<ButtonState, Float>> states = new HashMap<>();
+        for (ButtonBinding binding : BINDINGS) {
+            ButtonState state = binding.isAvailable(client) ? getBindingState(binding) : ButtonState.NONE;
+            if (skipButtons.stream().anyMatch(btn -> containsButton(binding.getButton(), btn))) {
+                if (binding.pressed)
+                    state = ButtonState.RELEASE;
+                else
+                    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, Pair.of(state, value));
+        }
+
+        states.forEach((binding, state) -> {
+            if (state.key != ButtonState.NONE) {
+                binding.handle(client, state.value, state.key);
+            }
+        });
+    }
+
+    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);
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/controller/MovementHandler.java

@@ -0,0 +1,98 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.controller;
+
+import me.lambdaurora.lambdacontrols.client.ButtonState;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.network.ClientPlayerEntity;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Represents the movement handler.
+ *
+ * @author LambdAurora
+ * @version 1.4.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 (direction == 0)
+            return false;
+
+        this.shouldOverrideMovement = true;
+
+        value = (float) Math.pow(value, 2);
+
+        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 true;
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/controller/PressAction.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.controller;
+
+import me.lambdaurora.lambdacontrols.client.ButtonState;
+import me.lambdaurora.lambdacontrols.client.util.KeyBindingAccessor;
+import net.minecraft.client.MinecraftClient;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Represents a press action callback.
+ *
+ * @author LambdAurora
+ * @version 1.4.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 -> ((KeyBindingAccessor) binding).lambdacontrols_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);
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/gui/ControllerButtonWidget.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.gui;
+
+import me.lambdaurora.lambdacontrols.LambdaControls;
+import me.lambdaurora.lambdacontrols.client.controller.ButtonBinding;
+import me.lambdaurora.spruceui.AbstractIconButtonWidget;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.text.LiteralText;
+import net.minecraft.text.Text;
+import org.aperlambda.lambdacommon.utils.Pair;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Represents a controller button widget.
+ */
+public class ControllerButtonWidget extends AbstractIconButtonWidget
+{
+    private ButtonBinding binding;
+    private int           iconWidth;
+
+    public ControllerButtonWidget(int x, int y, int width, @NotNull ButtonBinding binding, @NotNull PressAction action)
+    {
+        super(x, y, width, 20, ButtonBinding.getLocalizedButtonName(binding.getButton()[0]), action);
+        this.binding = binding;
+    }
+
+    public void update()
+    {
+        int length = binding.getButton().length;
+        this.setMessage(this.binding.isNotBound() ? LambdaControls.NOT_BOUND_TEXT :
+                (length > 0 ? ButtonBinding.getLocalizedButtonName(binding.getButton()[0]) : new LiteralText("<>")));
+    }
+
+    @Override
+    public Text getMessage()
+    {
+        if (this.binding.getButton().length > 1)
+            return LiteralText.EMPTY;
+        return super.getMessage();
+    }
+
+    @Override
+    protected int renderIcon(MatrixStack matrices, int mouseX, int mouseY, float delta, int x, int y)
+    {
+        if (this.binding.getButton().length > 1) {
+            x += (this.width / 2 - this.iconWidth / 2) - 4;
+        }
+        Pair<Integer, Integer> size = LambdaControlsRenderer.drawButton(matrices, x, y, this.binding, MinecraftClient.getInstance());
+        this.iconWidth = size.key;
+        return size.value;
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/gui/ControllerControlsScreen.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.gui;
+
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import me.lambdaurora.lambdacontrols.client.controller.ButtonBinding;
+import me.lambdaurora.lambdacontrols.client.controller.InputManager;
+import me.lambdaurora.spruceui.SpruceButtonWidget;
+import me.lambdaurora.spruceui.SpruceTexts;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.screen.options.ControlsOptionsScreen;
+import net.minecraft.client.gui.widget.ButtonWidget;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.text.TranslatableText;
+import org.aperlambda.lambdacommon.utils.function.Predicates;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Represents the controls screen.
+ */
+public class ControllerControlsScreen extends Screen
+{
+    private final Screen               parent;
+    final         LambdaControlsClient mod;
+    private final boolean              hideSettings;
+    private       ControlsListWidget   bindingsListWidget;
+    private       ButtonWidget         resetButton;
+    public        ButtonBinding        focusedBinding;
+    public        boolean              waiting        = false;
+    public        List<Integer>        currentButtons = new ArrayList<>();
+
+    public ControllerControlsScreen(@NotNull Screen parent, boolean hideSettings)
+    {
+        super(new TranslatableText("lambdacontrols.menu.title.controller_controls"));
+        this.parent = parent;
+        this.mod = LambdaControlsClient.get();
+        this.hideSettings = hideSettings;
+    }
+
+    @Override
+    public void removed()
+    {
+        this.mod.config.save();
+        super.removed();
+    }
+
+    @Override
+    protected void init()
+    {
+        this.addButton(new SpruceButtonWidget(this.width / 2 - 155, 18, this.hideSettings ? 310 : 150, 20,
+                new TranslatableText("lambdacontrols.menu.keyboard_controls"),
+                btn -> this.client.openScreen(new ControlsOptionsScreen(this, this.client.options))));
+        if (!this.hideSettings)
+            this.addButton(new SpruceButtonWidget(this.width / 2 - 155 + 160, 18, 150, 20,
+                    SpruceTexts.MENU_OPTIONS,
+                    btn -> this.client.openScreen(new LambdaControlsSettingsScreen(this, true))));
+        this.bindingsListWidget = new ControlsListWidget(this, this.client);
+        this.children.add(this.bindingsListWidget);
+        this.resetButton = this.addButton(new ButtonWidget(this.width / 2 - 155, this.height - 29, 150, 20,
+                new TranslatableText("controls.resetAll"),
+                btn -> InputManager.streamBindings().forEach(binding -> this.mod.config.setButtonBinding(binding, binding.getDefaultButton()))));
+        this.addButton(new ButtonWidget(this.width / 2 - 155 + 160, this.height - 29, 150, 20,
+                SpruceTexts.GUI_DONE,
+                btn -> this.client.openScreen(this.parent)));
+    }
+
+    @Override
+    public void render(MatrixStack matrices, int mouseX, int mouseY, float delta)
+    {
+        this.renderBackground(matrices);
+        this.bindingsListWidget.render(matrices, mouseX, mouseY, delta);
+        this.drawCenteredText(matrices, this.textRenderer, this.title, this.width / 2, 8, 16777215);
+        this.resetButton.active = InputManager.streamBindings().anyMatch(Predicates.not(ButtonBinding::isDefault));
+        super.render(matrices, mouseX, mouseY, delta);
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/gui/ControlsListWidget.java

@@ -0,0 +1,214 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.gui;
+
+import me.lambdaurora.lambdacontrols.client.controller.ButtonBinding;
+import me.lambdaurora.lambdacontrols.client.controller.ButtonCategory;
+import me.lambdaurora.lambdacontrols.client.controller.InputManager;
+import me.lambdaurora.spruceui.SpruceTexts;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.font.TextRenderer;
+import net.minecraft.client.gui.Element;
+import net.minecraft.client.gui.widget.ButtonWidget;
+import net.minecraft.client.gui.widget.ElementListWidget;
+import net.minecraft.client.resource.language.I18n;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.text.LiteralText;
+import net.minecraft.text.MutableText;
+import net.minecraft.text.TranslatableText;
+import net.minecraft.util.Formatting;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * Represents a control list widget.
+ */
+public class ControlsListWidget extends ElementListWidget<ControlsListWidget.Entry>
+{
+    private static final int[]                    UNBOUND = new int[0];
+    private final        ControllerControlsScreen gui;
+    private              int                      field_2733;
+
+    public ControlsListWidget(@NotNull ControllerControlsScreen gui, @NotNull MinecraftClient client)
+    {
+        super(client, gui.width + 45, gui.height, 43, gui.height - 32, 24);
+        this.gui = gui;
+
+        InputManager.streamCategories()
+                .sorted(Comparator.comparingInt(ButtonCategory::getPriority))
+                .forEach(category -> {
+                    this.addEntry(new CategoryEntry(category));
+
+                    category.getBindings().forEach(binding -> {
+                        int i = client.textRenderer.getWidth(I18n.translate(binding.getTranslationKey()));
+                        if (i > this.field_2733) {
+                            this.field_2733 = i;
+                        }
+
+                        this.addEntry(new ControlsListWidget.ButtonBindingEntry(binding));
+                    });
+                });
+    }
+
+    @Override
+    protected int getScrollbarPositionX()
+    {
+        return super.getScrollbarPositionX() + 15;
+    }
+
+    @Override
+    public int getRowWidth()
+    {
+        return super.getRowWidth() + 32;
+    }
+
+    public class ButtonBindingEntry extends Entry
+    {
+        private final ButtonBinding          binding;
+        private final String                 bindingName;
+        private final ControllerButtonWidget editButton;
+        private final ButtonWidget           resetButton;
+        private final ButtonWidget           unboundButton;
+
+        ButtonBindingEntry(@NotNull ButtonBinding binding)
+        {
+            this.binding = binding;
+            this.bindingName = I18n.translate(this.binding.getTranslationKey());
+            this.editButton = new ControllerButtonWidget(0, 0, 110, this.binding, btn -> {
+                gui.focusedBinding = binding;
+                gui.currentButtons.clear();
+                gui.waiting = true;
+            })
+            {
+                protected MutableText getNarrationMessage()
+                {
+                    return binding.isNotBound() ? new TranslatableText("narrator.controls.unbound", bindingName) : new TranslatableText("narrator.controls.bound", bindingName, super.getNarrationMessage());
+                }
+            };
+            this.resetButton = new ButtonWidget(0, 0, 50, 20, new TranslatableText("controls.reset"),
+                    btn -> gui.mod.config.setButtonBinding(binding, binding.getDefaultButton()))
+            {
+                protected MutableText getNarrationMessage()
+                {
+                    return new TranslatableText("narrator.controls.reset", bindingName);
+                }
+            };
+            this.unboundButton = new ButtonWidget(0, 0, 50, 20, SpruceTexts.OPTIONS_GENERIC_UNBOUND,
+                    btn -> {
+                        gui.mod.config.setButtonBinding(binding, UNBOUND);
+                        gui.focusedBinding = null;
+                    })
+            {
+                protected MutableText getNarrationMessage()
+                {
+                    return new TranslatableText("lambdacontrols.narrator.unbound", bindingName);
+                }
+            };
+        }
+
+        @Override
+        public List<? extends Element> children()
+        {
+            return Collections.unmodifiableList(Arrays.asList(this.editButton, this.resetButton));
+        }
+
+        @Override
+        public void render(MatrixStack matrices, int index, int y, int x, int width, int height, int mouseX, int mouseY, boolean hovering, float delta)
+        {
+            boolean focused = gui.focusedBinding == this.binding;
+            TextRenderer textRenderer = ControlsListWidget.this.client.textRenderer;
+            String bindingName = this.bindingName;
+            float var10002 = (float) (x + 70 - ControlsListWidget.this.field_2733);
+            int var10003 = y + height / 2;
+            textRenderer.draw(matrices, bindingName, var10002, (float) (var10003 - 9 / 2), 16777215);
+            this.resetButton.x = this.unboundButton.x = x + 190;
+            this.resetButton.y = this.unboundButton.y = y;
+            this.resetButton.active = !this.binding.isDefault();
+            if (focused)
+                this.unboundButton.render(matrices, mouseX, mouseY, delta);
+            else
+                this.resetButton.render(matrices, mouseX, mouseY, delta);
+            this.editButton.x = x + 75;
+            this.editButton.y = y;
+            this.editButton.update();
+
+            if (focused) {
+                MutableText text = new LiteralText("> ").formatted(Formatting.WHITE);
+                text.append(this.editButton.getMessage().copy().formatted(Formatting.YELLOW));
+                this.editButton.setMessage(text.append(new LiteralText(" <").formatted(Formatting.WHITE)));
+            } else if (!this.binding.isNotBound() && InputManager.hasDuplicatedBindings(this.binding)) {
+                MutableText text = this.editButton.getMessage().copy();
+                this.editButton.setMessage(text.formatted(Formatting.RED));
+            } else if (this.binding.isNotBound()) {
+                MutableText text = this.editButton.getMessage().copy();
+                this.editButton.setMessage(text.formatted(Formatting.GOLD));
+            }
+
+            this.editButton.render(matrices, mouseX, mouseY, delta);
+        }
+
+        public boolean mouseClicked(double mouseX, double mouseY, int button)
+        {
+            boolean focused = gui.focusedBinding == this.binding;
+            if (this.editButton.mouseClicked(mouseX, mouseY, button))
+                return true;
+            else
+                return focused ? this.unboundButton.mouseClicked(mouseX, mouseY, button) : this.resetButton.mouseClicked(mouseX, mouseY, button);
+        }
+
+        public boolean mouseReleased(double mouseX, double mouseY, int button)
+        {
+            return this.editButton.mouseReleased(mouseX, mouseY, button) || this.resetButton.mouseReleased(mouseX, mouseY, button)
+                    || this.unboundButton.mouseReleased(mouseX, mouseY, button);
+        }
+    }
+
+    public class CategoryEntry extends Entry
+    {
+        private final String name;
+        private final int    nameWidth;
+
+        public CategoryEntry(@NotNull ButtonCategory category)
+        {
+            this.name = category.getTranslatedName();
+            this.nameWidth = ControlsListWidget.this.client.textRenderer.getWidth(this.name);
+        }
+
+        @Override
+        public void render(MatrixStack matrices, int index, int y, int x, int width, int height, int mouseX, int mouseY, boolean hovering, float delta)
+        {
+            ControlsListWidget.this.client.textRenderer.draw(matrices, this.name, (float) (ControlsListWidget.this.client.currentScreen.width / 2 - this.nameWidth / 2),
+                    (float) ((y + height) - 9 - 1), 16777215);
+        }
+
+        @Override
+        public boolean changeFocus(boolean bl)
+        {
+            return false;
+        }
+
+        @Override
+        public List<? extends Element> children()
+        {
+            return Collections.emptyList();
+        }
+    }
+
+    @Environment(EnvType.CLIENT)
+    public abstract static class Entry extends ElementListWidget.Entry<Entry>
+    {
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/gui/LambdaControlsHud.java

@@ -0,0 +1,293 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.gui;
+
+import me.lambdaurora.lambdacontrols.ControlsMode;
+import me.lambdaurora.lambdacontrols.LambdaControlsConstants;
+import me.lambdaurora.lambdacontrols.client.HudSide;
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import me.lambdaurora.lambdacontrols.client.compat.LambdaControlsCompat;
+import me.lambdaurora.lambdacontrols.client.controller.ButtonBinding;
+import me.lambdaurora.spruceui.hud.Hud;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.resource.language.I18n;
+import net.minecraft.client.util.Window;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.item.BlockItem;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.hit.BlockHitResult;
+import net.minecraft.util.hit.HitResult;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Represents the LambdaControls HUD.
+ *
+ * @author LambdAurora
+ * @version 1.3.2
+ * @since 1.0.0
+ */
+public class LambdaControlsHud extends Hud
+{
+    private final LambdaControlsClient mod;
+    private       MinecraftClient      client;
+    private       int                  attackWidth             = 0;
+    private       int                  attackButtonWidth       = 0;
+    private       int                  dropItemWidth           = 0;
+    private       int                  dropItemButtonWidth     = 0;
+    private       int                  inventoryWidth          = 0;
+    private       int                  inventoryButtonWidth    = 0;
+    private       int                  swapHandsWidth          = 0;
+    private       int                  swapHandsButtonWidth    = 0;
+    private       int                  useWidth                = 0;
+    private       int                  useButtonWidth          = 0;
+    private       BlockHitResult       placeHitResult;
+    private       String               attackAction            = "";
+    private       String               placeAction             = "";
+    private       int                  ticksDisplayedCrosshair = 0;
+
+    public LambdaControlsHud(@NotNull LambdaControlsClient mod)
+    {
+        super(new Identifier(LambdaControlsConstants.NAMESPACE, "hud/button_indicator"));
+        this.mod = mod;
+    }
+
+    @Override
+    public void init(@NotNull MinecraftClient client, int screenWidth, int screenHeight)
+    {
+        super.init(client, screenWidth, screenHeight);
+        this.client = client;
+        this.inventoryWidth = this.width(ButtonBinding.INVENTORY);
+        this.inventoryButtonWidth = LambdaControlsRenderer.getBindingIconWidth(ButtonBinding.INVENTORY);
+        this.swapHandsWidth = this.width(ButtonBinding.SWAP_HANDS);
+        this.swapHandsButtonWidth = LambdaControlsRenderer.getBindingIconWidth(ButtonBinding.SWAP_HANDS);
+        this.dropItemWidth = this.width(ButtonBinding.DROP_ITEM);
+        this.dropItemButtonWidth = LambdaControlsRenderer.getBindingIconWidth(ButtonBinding.DROP_ITEM);
+        this.attackButtonWidth = LambdaControlsRenderer.getBindingIconWidth(ButtonBinding.ATTACK);
+        this.useButtonWidth = LambdaControlsRenderer.getBindingIconWidth(ButtonBinding.USE);
+    }
+
+    /**
+     * Renders the LambdaControls' HUD.
+     */
+    @Override
+    public void render(MatrixStack matrices, float tickDelta)
+    {
+        if (this.mod.config.getControlsMode() == ControlsMode.CONTROLLER && this.client.currentScreen == null) {
+            int y = bottom(2);
+            this.renderFirstIcons(matrices, this.mod.config.getHudSide() == HudSide.LEFT ? 2 : client.getWindow().getScaledWidth() - 2, y);
+            this.renderSecondIcons(matrices, this.mod.config.getHudSide() == HudSide.RIGHT ? 2 : client.getWindow().getScaledWidth() - 2, y);
+            this.renderFirstSection(matrices, this.mod.config.getHudSide() == HudSide.LEFT ? 2 : client.getWindow().getScaledWidth() - 2, y);
+            this.renderSecondSection(matrices, this.mod.config.getHudSide() == HudSide.RIGHT ? 2 : client.getWindow().getScaledWidth() - 2, y);
+        }
+
+        if (this.mod.reacharound.isLastReacharoundVertical()) {
+            // Render crosshair indicator.
+            Window window = this.client.getWindow();
+            String text = "[  ]";
+
+            float scale = Math.min(5, this.ticksDisplayedCrosshair + tickDelta) / 5F;
+            scale *= scale;
+            int opacity = ((int) (255 * scale)) << 24;
+
+            this.client.textRenderer.draw(matrices, text, window.getScaledWidth() / 2.f - this.client.textRenderer.getWidth(text) / 2.f,
+                    window.getScaledHeight() / 2.f - 4, 0xCCCCCC | opacity);
+        }
+    }
+
+    public void renderFirstIcons(MatrixStack matrices, int x, int y)
+    {
+        int offset = 2 + this.inventoryWidth + this.inventoryButtonWidth + 4;
+        int currentX = this.mod.config.getHudSide() == HudSide.LEFT ? x : x - this.inventoryButtonWidth;
+        this.drawButton(matrices, currentX, y, ButtonBinding.INVENTORY, true);
+        this.drawButton(matrices, currentX += (this.mod.config.getHudSide() == HudSide.LEFT ? offset : -offset), y, ButtonBinding.SWAP_HANDS, true);
+        offset = 2 + this.swapHandsWidth + this.dropItemButtonWidth + 4;
+        if (this.client.options.showSubtitles && this.mod.config.getHudSide() == HudSide.RIGHT) {
+            currentX += -offset;
+        } else {
+            currentX = this.mod.config.getHudSide() == HudSide.LEFT ? x : x - this.dropItemButtonWidth;
+            y -= 24;
+        }
+        this.drawButton(matrices, currentX, y, ButtonBinding.DROP_ITEM, !this.client.player.getMainHandStack().isEmpty());
+    }
+
+    public void renderSecondIcons(MatrixStack matrices, int x, int y)
+    {
+        int offset;
+        int currentX = x;
+        if (!this.placeAction.isEmpty()) {
+            if (this.mod.config.getHudSide() == HudSide.LEFT)
+                currentX -= this.useButtonWidth;
+            this.drawButton(matrices, currentX, y, ButtonBinding.USE, true);
+            offset = 2 + this.useWidth + 4;
+            if (this.client.options.showSubtitles && this.mod.config.getHudSide() == HudSide.LEFT) {
+                currentX -= offset;
+            } else {
+                currentX = x;
+                y -= 24;
+            }
+        }
+
+        if (this.mod.config.getHudSide() == HudSide.LEFT)
+            currentX -= this.attackButtonWidth;
+
+        this.drawButton(matrices, currentX, y, ButtonBinding.ATTACK, this.attackWidth != 0);
+    }
+
+    public void renderFirstSection(MatrixStack matrices, int x, int y)
+    {
+        int currentX = this.mod.config.getHudSide() == HudSide.LEFT ? x + this.inventoryButtonWidth + 2 : x - this.inventoryButtonWidth - 2 - this.inventoryWidth;
+        this.drawTip(matrices, currentX, y, ButtonBinding.INVENTORY, true);
+        currentX += this.mod.config.getHudSide() == HudSide.LEFT ? this.inventoryWidth + 4 + this.swapHandsButtonWidth + 2
+                : -this.swapHandsWidth - 2 - this.swapHandsButtonWidth - 4;
+        this.drawTip(matrices, currentX, y, ButtonBinding.SWAP_HANDS, true);
+        if (this.client.options.showSubtitles && this.mod.config.getHudSide() == HudSide.RIGHT) {
+            currentX += -this.dropItemWidth - 2 - this.dropItemButtonWidth - 4;
+        } else {
+            y -= 24;
+            currentX = this.mod.config.getHudSide() == HudSide.LEFT ? x + this.dropItemButtonWidth + 2 : x - this.dropItemButtonWidth - 2 - this.dropItemWidth;
+        }
+        this.drawTip(matrices, currentX, y, ButtonBinding.DROP_ITEM, !this.client.player.getMainHandStack().isEmpty());
+    }
+
+    public void renderSecondSection(MatrixStack matrices, int x, int y)
+    {
+        int currentX = x;
+
+        if (!this.placeAction.isEmpty()) {
+            currentX += this.mod.config.getHudSide() == HudSide.RIGHT ? this.useButtonWidth + 2 : -this.useButtonWidth - 2 - this.useWidth;
+
+            this.drawTip(matrices, currentX, y, this.placeAction, true);
+
+            if (this.client.options.showSubtitles && this.mod.config.getHudSide() == HudSide.LEFT) {
+                currentX -= 4;
+            } else {
+                currentX = x;
+                y -= 24;
+            }
+        }
+
+        currentX += this.mod.config.getHudSide() == HudSide.RIGHT ? this.attackButtonWidth + 2 : -this.attackButtonWidth - 2 - this.attackWidth;
+
+        this.drawTip(matrices, currentX, y, this.attackAction, this.attackWidth != 0);
+    }
+
+    @Override
+    public void tick()
+    {
+        super.tick();
+        if (this.mod.config.getControlsMode() == ControlsMode.CONTROLLER) {
+            if (this.client.crosshairTarget == null)
+                return;
+
+            String placeAction;
+
+            // Update "Use" tip status.
+            if (this.client.crosshairTarget.getType() == HitResult.Type.MISS) {
+                this.placeHitResult = this.mod.reacharound.getLastReacharoundResult();
+                this.attackAction = "";
+                this.attackWidth = 0;
+            } else {
+                if (this.client.crosshairTarget.getType() == HitResult.Type.BLOCK)
+                    this.placeHitResult = (BlockHitResult) this.client.crosshairTarget;
+                else
+                    this.placeHitResult = null;
+
+                this.attackAction = this.client.crosshairTarget.getType() == HitResult.Type.BLOCK ? "lambdacontrols.action.hit" : ButtonBinding.ATTACK.getTranslationKey();
+                this.attackWidth = this.width(attackAction);
+            }
+
+            if (this.mod.reacharound.isLastReacharoundVertical()) {
+                if (this.ticksDisplayedCrosshair < 5)
+                    this.ticksDisplayedCrosshair++;
+            } else {
+                this.ticksDisplayedCrosshair = 0;
+            }
+
+            String customAttackAction = LambdaControlsCompat.getAttackActionAt(this.client, this.placeHitResult);
+            if (customAttackAction != null) {
+                this.attackAction = customAttackAction;
+                this.attackWidth = this.width(customAttackAction);
+            }
+
+            ItemStack stack = null;
+            if (this.client.player != null) {
+                stack = this.client.player.getMainHandStack();
+                if (stack == null || stack.isEmpty())
+                    stack = this.client.player.getOffHandStack();
+            }
+            if (stack == null || stack.isEmpty()) {
+                placeAction = "";
+            } else {
+                if (this.placeHitResult != null && stack.getItem() instanceof BlockItem) {
+                    placeAction = "lambdacontrols.action.place";
+                } else {
+                    placeAction = ButtonBinding.USE.getTranslationKey();
+                }
+            }
+
+            String customUseAction = LambdaControlsCompat.getUseActionAt(this.client, this.placeHitResult);
+            if (customUseAction != null)
+                placeAction = customUseAction;
+
+            this.placeAction = placeAction;
+
+            // Cache the "Use" tip width.
+            if (this.placeAction.isEmpty())
+                this.useWidth = 0;
+            else
+                this.useWidth = this.width(this.placeAction);
+        }
+    }
+
+    @Override
+    public boolean hasTicks()
+    {
+        return true;
+    }
+
+    private int bottom(int y)
+    {
+        return this.client.getWindow().getScaledHeight() - y - LambdaControlsRenderer.ICON_SIZE;
+    }
+
+    private int width(@NotNull ButtonBinding binding)
+    {
+        return this.width(binding.getTranslationKey());
+    }
+
+    private int width(@Nullable String text)
+    {
+        if (text == null || text.isEmpty())
+            return 0;
+        return this.client.textRenderer.getWidth(I18n.translate(text));
+    }
+
+    private void drawButton(MatrixStack matrices, int x, int y, @NotNull ButtonBinding button, boolean display)
+    {
+        if (display)
+            LambdaControlsRenderer.drawButton(matrices, x, y, button, this.client);
+    }
+
+    private void drawTip(MatrixStack matrices, int x, int y, @NotNull ButtonBinding button, boolean display)
+    {
+        this.drawTip(matrices, x, y, button.getTranslationKey(), display);
+    }
+
+    private void drawTip(MatrixStack matrices, int x, int y, @NotNull String action, boolean display)
+    {
+        if (!display)
+            return;
+        String translatedAction = I18n.translate(action);
+        int textY = (LambdaControlsRenderer.ICON_SIZE / 2 - this.client.textRenderer.fontHeight / 2) + 1;
+        this.client.textRenderer.draw(matrices, translatedAction, (float) x, (float) (y + textY), 14737632);
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/gui/LambdaControlsRenderer.java

@@ -0,0 +1,281 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.gui;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import me.lambdaurora.lambdacontrols.client.LambdaInput;
+import me.lambdaurora.lambdacontrols.client.controller.ButtonBinding;
+import me.lambdaurora.lambdacontrols.client.util.HandledScreenAccessor;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.font.TextRenderer;
+import net.minecraft.client.gui.DrawableHelper;
+import net.minecraft.client.gui.screen.ingame.HandledScreen;
+import net.minecraft.client.resource.language.I18n;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.screen.slot.Slot;
+import org.aperlambda.lambdacommon.utils.Pair;
+import org.jetbrains.annotations.NotNull;
+import org.lwjgl.glfw.GLFW;
+
+/**
+ * Represents the LambdaControls renderer.
+ *
+ * @author LambdAurora
+ * @version 1.3.2
+ * @since 1.2.0
+ */
+public class LambdaControlsRenderer
+{
+    public static final  int ICON_SIZE   = 20;
+    private static final int BUTTON_SIZE = 15;
+    private static final int AXIS_SIZE   = 18;
+
+    public static int getButtonSize(int button)
+    {
+        switch (button) {
+            case -1:
+                return 0;
+            case GLFW.GLFW_GAMEPAD_AXIS_LEFT_X + 100:
+            case GLFW.GLFW_GAMEPAD_AXIS_LEFT_X + 200:
+            case GLFW.GLFW_GAMEPAD_AXIS_LEFT_Y + 100:
+            case GLFW.GLFW_GAMEPAD_AXIS_LEFT_Y + 200:
+            case GLFW.GLFW_GAMEPAD_AXIS_RIGHT_X + 100:
+            case GLFW.GLFW_GAMEPAD_AXIS_RIGHT_X + 200:
+            case GLFW.GLFW_GAMEPAD_AXIS_RIGHT_Y + 100:
+            case GLFW.GLFW_GAMEPAD_AXIS_RIGHT_Y + 200:
+                return AXIS_SIZE;
+            default:
+                return BUTTON_SIZE;
+        }
+    }
+
+    /**
+     * Gets the binding icon width.
+     *
+     * @param binding The binding.
+     * @return The width.
+     */
+    public static int getBindingIconWidth(@NotNull ButtonBinding binding)
+    {
+        return getBindingIconWidth(binding.getButton());
+    }
+
+    /**
+     * Gets the binding icon width.
+     *
+     * @param buttons The buttons.
+     * @return The width.
+     */
+    public static int getBindingIconWidth(int[] buttons)
+    {
+        int width = 0;
+        for (int i = 0; i < buttons.length; i++) {
+            width += ICON_SIZE;
+            if (i + 1 < buttons.length) {
+                width += 2;
+            }
+        }
+        return width;
+    }
+
+    public static Pair<Integer, Integer> drawButton(MatrixStack matrices, int x, int y, @NotNull ButtonBinding button, @NotNull MinecraftClient client)
+    {
+        return drawButton(matrices, x, y, button.getButton(), client);
+    }
+
+    public static Pair<Integer, Integer> drawButton(MatrixStack matrices, int x, int y, int[] buttons, @NotNull MinecraftClient client)
+    {
+        int height = 0;
+        int length = 0;
+        int currentX = x;
+        for (int i = 0; i < buttons.length; i++) {
+            int btn = buttons[i];
+            int size = drawButton(matrices, currentX, y, btn, client);
+            if (size > height)
+                height = size;
+            length += size;
+            if (i + 1 < buttons.length) {
+                length += 2;
+                currentX = x + length;
+            }
+        }
+        return Pair.of(length, height);
+    }
+
+    @SuppressWarnings("deprecated")
+    public static int drawButton(MatrixStack matrices, int x, int y, int button, @NotNull MinecraftClient client)
+    {
+        boolean second = false;
+        if (button == -1)
+            return 0;
+        else if (button >= 500) {
+            button -= 1000;
+            second = true;
+        }
+
+        int controllerType = LambdaControlsClient.get().config.getControllerType().getId();
+        boolean axis = false;
+        int buttonOffset = button * 15;
+        switch (button) {
+            case GLFW.GLFW_GAMEPAD_BUTTON_LEFT_BUMPER:
+                buttonOffset = 7 * 15;
+                break;
+            case GLFW.GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER:
+                buttonOffset = 8 * 15;
+                break;
+            case GLFW.GLFW_GAMEPAD_BUTTON_BACK:
+                buttonOffset = 4 * 15;
+                break;
+            case GLFW.GLFW_GAMEPAD_BUTTON_START:
+                buttonOffset = 6 * 15;
+                break;
+            case GLFW.GLFW_GAMEPAD_BUTTON_GUIDE:
+                buttonOffset = 5 * 15;
+                break;
+            case GLFW.GLFW_GAMEPAD_BUTTON_LEFT_THUMB:
+                buttonOffset = 15 * 15;
+                break;
+            case GLFW.GLFW_GAMEPAD_BUTTON_RIGHT_THUMB:
+                buttonOffset = 16 * 15;
+                break;
+            case GLFW.GLFW_GAMEPAD_AXIS_LEFT_X + 100:
+                buttonOffset = 0;
+                axis = true;
+                break;
+            case GLFW.GLFW_GAMEPAD_AXIS_LEFT_Y + 100:
+                buttonOffset = 18;
+                axis = true;
+                break;
+            case GLFW.GLFW_GAMEPAD_AXIS_RIGHT_X + 100:
+                buttonOffset = 2 * 18;
+                axis = true;
+                break;
+            case GLFW.GLFW_GAMEPAD_AXIS_RIGHT_Y + 100:
+                buttonOffset = 3 * 18;
+                axis = true;
+                break;
+            case GLFW.GLFW_GAMEPAD_AXIS_LEFT_X + 200:
+                buttonOffset = 4 * 18;
+                axis = true;
+                break;
+            case GLFW.GLFW_GAMEPAD_AXIS_LEFT_Y + 200:
+                buttonOffset = 5 * 18;
+                axis = true;
+                break;
+            case GLFW.GLFW_GAMEPAD_AXIS_RIGHT_X + 200:
+                buttonOffset = 6 * 18;
+                axis = true;
+                break;
+            case GLFW.GLFW_GAMEPAD_AXIS_RIGHT_Y + 200:
+                buttonOffset = 7 * 18;
+                axis = true;
+                break;
+            case GLFW.GLFW_GAMEPAD_AXIS_LEFT_TRIGGER + 100:
+            case GLFW.GLFW_GAMEPAD_AXIS_LEFT_TRIGGER + 200:
+                buttonOffset = 9 * 15;
+                break;
+            case GLFW.GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER + 100:
+            case GLFW.GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER + 200:
+                buttonOffset = 10 * 15;
+                break;
+        }
+
+        client.getTextureManager().bindTexture(axis ? LambdaControlsClient.CONTROLLER_AXIS : LambdaControlsClient.CONTROLLER_BUTTONS);
+        RenderSystem.disableDepthTest();
+
+        int assetSize = axis ? AXIS_SIZE : BUTTON_SIZE;
+
+        RenderSystem.color4f(1.0F, second ? 0.0F : 1.0F, 1.0F, 1.0F);
+        DrawableHelper.drawTexture(matrices, x + (ICON_SIZE / 2 - assetSize / 2), y + (ICON_SIZE / 2 - assetSize / 2),
+                (float) buttonOffset, (float) (controllerType * (axis ? AXIS_SIZE : BUTTON_SIZE)),
+                assetSize, assetSize,
+                256, 256);
+        RenderSystem.enableDepthTest();
+
+        return ICON_SIZE;
+    }
+
+    public static int drawButtonTip(MatrixStack matrices, int x, int y, @NotNull ButtonBinding button, boolean display, @NotNull MinecraftClient client)
+    {
+        return drawButtonTip(matrices, x, y, button.getButton(), button.getTranslationKey(), display, client);
+    }
+
+    public static int drawButtonTip(MatrixStack matrices, int x, int y, int[] button, @NotNull String action, boolean display, @NotNull MinecraftClient client)
+    {
+        if (display) {
+            int buttonWidth = drawButton(matrices, x, y, button, client).key;
+
+            String translatedAction = I18n.translate(action);
+            int textY = (LambdaControlsRenderer.ICON_SIZE / 2 - client.textRenderer.fontHeight / 2) + 1;
+
+            return client.textRenderer.drawWithShadow(matrices, translatedAction, (float) (x + buttonWidth + 2), (float) (y + textY), 14737632);
+        }
+
+        return -10;
+    }
+
+    private static int getButtonTipWidth(@NotNull String action, @NotNull TextRenderer textRenderer)
+    {
+        return 15 + 5 + textRenderer.getWidth(action);
+    }
+
+    public static void renderVirtualCursor(@NotNull MatrixStack matrices, @NotNull MinecraftClient client)
+    {
+        if (!LambdaControlsClient.get().config.hasVirtualMouse() || (client.currentScreen == null || LambdaInput.isScreenInteractive(client.currentScreen)))
+            return;
+
+        int mouseX = (int) (client.mouse.getX() * (double) client.getWindow().getScaledWidth() / (double) client.getWindow().getWidth());
+        int mouseY = (int) (client.mouse.getY() * (double) client.getWindow().getScaledHeight() / (double) client.getWindow().getHeight());
+
+        boolean hoverSlot = false;
+
+        if (client.currentScreen instanceof HandledScreen) {
+            HandledScreenAccessor inventoryScreen = (HandledScreenAccessor) client.currentScreen;
+            int guiLeft = inventoryScreen.getX();
+            int guiTop = inventoryScreen.getY();
+
+            Slot slot = inventoryScreen.lambdacontrols_getSlotAt(mouseX, mouseY);
+
+            if (slot != null) {
+                mouseX = guiLeft + slot.x;
+                mouseY = guiTop + slot.y;
+                hoverSlot = true;
+            }
+        }
+
+        if (!hoverSlot) {
+            mouseX -= 8;
+            mouseY -= 8;
+        }
+
+        drawCursor(matrices, mouseX, mouseY, hoverSlot, client);
+    }
+
+    /**
+     * Draws the virtual cursor.
+     *
+     * @param matrices  The matrix stack.
+     * @param x         X coordinate.
+     * @param y         Y coordinate.
+     * @param hoverSlot True if hovering a slot, else false.
+     * @param client    The client instance.
+     */
+    public static void drawCursor(@NotNull MatrixStack matrices, int x, int y, boolean hoverSlot, @NotNull MinecraftClient client)
+    {
+        client.getTextureManager().bindTexture(LambdaControlsClient.CURSOR_TEXTURE);
+
+        RenderSystem.disableDepthTest();
+
+        RenderSystem.color4f(1.0F, 1.0F, 1.0F, 1.0F);
+        DrawableHelper.drawTexture(matrices, x, y, hoverSlot ? 16.F : 0.F, LambdaControlsClient.get().config.getVirtualMouseSkin().ordinal() * 16.F, 16, 16, 32, 64);
+        RenderSystem.enableDepthTest();
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/gui/LambdaControlsSettingsScreen.java

@@ -0,0 +1,287 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.gui;
+
+import me.lambdaurora.lambdacontrols.ControlsMode;
+import me.lambdaurora.lambdacontrols.LambdaControls;
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import me.lambdaurora.lambdacontrols.client.controller.Controller;
+import me.lambdaurora.spruceui.SpruceButtonWidget;
+import me.lambdaurora.spruceui.SpruceLabelWidget;
+import me.lambdaurora.spruceui.SpruceTexts;
+import me.lambdaurora.spruceui.Tooltip;
+import me.lambdaurora.spruceui.option.*;
+import net.fabricmc.fabric.api.network.ClientSidePacketRegistry;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.screen.options.ControlsOptionsScreen;
+import net.minecraft.client.gui.widget.ButtonListWidget;
+import net.minecraft.client.gui.widget.ButtonWidget;
+import net.minecraft.client.options.Option;
+import net.minecraft.client.resource.language.I18n;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.text.LiteralText;
+import net.minecraft.text.MutableText;
+import net.minecraft.text.TranslatableText;
+import net.minecraft.util.Formatting;
+import net.minecraft.util.Util;
+import org.lwjgl.glfw.GLFW;
+
+/**
+ * Represents the LambdaControls settings screen.
+ */
+public class LambdaControlsSettingsScreen extends Screen
+{
+    public static final String               GAMEPAD_TOOL_URL          = "https://generalarcade.com/gamepadtool/";
+    final               LambdaControlsClient mod;
+    private final       Screen               parent;
+    private final       boolean              hideControls;
+    // General options
+    private final       Option               autoSwitchModeOption;
+    private final       Option               rotationSpeedOption;
+    private final       Option               mouseSpeedOption;
+    private final       Option               resetOption;
+    // Gameplay options
+    private final       Option               autoJumpOption;
+    private final       Option               fastBlockPlacingOption;
+    private final       Option               frontBlockPlacingOption;
+    private final       Option               verticalReacharoundOption;
+    private final       Option               flyDriftingOption;
+    private final       Option               flyVerticalDriftingOption;
+    // Controller options
+    private final       Option               controllerOption;
+    private final       Option               secondControllerOption;
+    private final       Option               controllerTypeOption;
+    private final       Option               deadZoneOption;
+    private final       Option               invertsRightXAxis;
+    private final       Option               invertsRightYAxis;
+    private final       Option               unfocusedInputOption;
+    private final       Option               virtualMouseOption;
+    private final       Option               virtualMouseSkinOption;
+    // Hud options
+    private final       Option               hudEnableOption;
+    private final       Option               hudSideOption;
+    private final       MutableText          controllerMappingsUrlText = new LiteralText("(")
+            .append(new LiteralText(GAMEPAD_TOOL_URL).formatted(Formatting.GOLD))
+            .append("),");
+    private             ButtonListWidget     list;
+    private             SpruceLabelWidget    gamepadToolUrlLabel;
+
+    public LambdaControlsSettingsScreen(Screen parent, boolean hideControls)
+    {
+        super(new TranslatableText("lambdacontrols.title.settings"));
+        this.mod = LambdaControlsClient.get();
+        this.parent = parent;
+        this.hideControls = hideControls;
+        // General options
+        this.autoSwitchModeOption = new SpruceBooleanOption("lambdacontrols.menu.auto_switch_mode", this.mod.config::hasAutoSwitchMode,
+                this.mod.config::setAutoSwitchMode, new TranslatableText("lambdacontrols.tooltip.auto_switch_mode"), true);
+        this.rotationSpeedOption = new SpruceDoubleOption("lambdacontrols.menu.rotation_speed", 0.0, 100.0, 0.5F, this.mod.config::getRotationSpeed,
+                newValue -> {
+                    synchronized (this.mod.config) {
+                        this.mod.config.setRotationSpeed(newValue);
+                    }
+                }, option -> option.getDisplayText(new LiteralText(String.valueOf(option.get()))),
+                new TranslatableText("lambdacontrols.tooltip.rotation_speed"));
+        this.mouseSpeedOption = new SpruceDoubleOption("lambdacontrols.menu.mouse_speed", 0.0, 150.0, 0.5F, this.mod.config::getMouseSpeed,
+                newValue -> {
+                    synchronized (this.mod.config) {
+                        this.mod.config.setMouseSpeed(newValue);
+                    }
+                }, option -> option.getDisplayText(new LiteralText(String.valueOf(option.get()))),
+                new TranslatableText("lambdacontrols.tooltip.mouse_speed"));
+        this.resetOption = new SpruceResetOption(btn -> {
+            this.mod.config.reset();
+            MinecraftClient client = MinecraftClient.getInstance();
+            this.init(client, client.getWindow().getScaledWidth(), client.getWindow().getScaledHeight());
+        });
+        // Gameplay options
+        this.autoJumpOption = SpruceBooleanOption.fromVanilla("options.autoJump", Option.AUTO_JUMP, null, true);
+        this.fastBlockPlacingOption = new SpruceBooleanOption("lambdacontrols.menu.fast_block_placing", this.mod.config::hasFastBlockPlacing,
+                this.mod.config::setFastBlockPlacing, new TranslatableText("lambdacontrols.tooltip.fast_block_placing"), true);
+        this.frontBlockPlacingOption = new SpruceBooleanOption("lambdacontrols.menu.reacharound.horizontal", this.mod.config::hasFrontBlockPlacing,
+                this.mod.config::setFrontBlockPlacing, new TranslatableText("lambdacontrols.tooltip.reacharound.horizontal"), true);
+        this.verticalReacharoundOption = new SpruceBooleanOption("lambdacontrols.menu.reacharound.vertical", this.mod.config::hasVerticalReacharound,
+                this.mod.config::setVerticalReacharound, new TranslatableText("lambdacontrols.tooltip.reacharound.vertical"), true);
+        this.flyDriftingOption = new SpruceBooleanOption("lambdacontrols.menu.fly_drifting", this.mod.config::hasFlyDrifting,
+                this.mod.config::setFlyDrifting, new TranslatableText("lambdacontrols.tooltip.fly_drifting"), true);
+        this.flyVerticalDriftingOption = new SpruceBooleanOption("lambdacontrols.menu.fly_drifting_vertical", this.mod.config::hasFlyVerticalDrifting,
+                this.mod.config::setFlyVerticalDrifting, new TranslatableText("lambdacontrols.tooltip.fly_drifting_vertical"), true);
+        // Controller options
+        this.controllerOption = new SpruceCyclingOption("lambdacontrols.menu.controller", amount -> {
+            int id = this.mod.config.getController().getId();
+            id += amount;
+            if (id > GLFW.GLFW_JOYSTICK_LAST)
+                id = GLFW.GLFW_JOYSTICK_1;
+            this.mod.config.setController(Controller.byId(id));
+        }, option -> {
+            String controllerName = this.mod.config.getController().getName();
+            if (!this.mod.config.getController().isConnected())
+                return option.getDisplayText(new LiteralText(controllerName).formatted(Formatting.RED));
+            else if (!this.mod.config.getController().isGamepad())
+                return option.getDisplayText(new LiteralText(controllerName).formatted(Formatting.GOLD));
+            else
+                return option.getDisplayText(new LiteralText(controllerName));
+        }, null);
+        this.secondControllerOption = new SpruceCyclingOption("lambdacontrols.menu.controller2",
+                amount -> {
+                    int id = this.mod.config.getSecondController().map(Controller::getId).orElse(-1);
+                    id += amount;
+                    if (id > GLFW.GLFW_JOYSTICK_LAST)
+                        id = -1;
+                    this.mod.config.setSecondController(id == -1 ? null : Controller.byId(id));
+                }, option -> this.mod.config.getSecondController().map(controller -> {
+            String controllerName = controller.getName();
+            if (!controller.isConnected())
+                return option.getDisplayText(new LiteralText(controllerName).formatted(Formatting.RED));
+            else if (!controller.isGamepad())
+                return option.getDisplayText(new LiteralText(controllerName).formatted(Formatting.GOLD));
+            else
+                return option.getDisplayText(new LiteralText(controllerName));
+        }).orElse(option.getDisplayText(SpruceTexts.OPTIONS_OFF.shallowCopy().formatted(Formatting.RED))),
+                new TranslatableText("lambdacontrols.tooltip.controller2"));
+        this.controllerTypeOption = new SpruceCyclingOption("lambdacontrols.menu.controller_type",
+                amount -> this.mod.config.setControllerType(this.mod.config.getControllerType().next()),
+                option -> option.getDisplayText(this.mod.config.getControllerType().getTranslatedText()),
+                new TranslatableText("lambdacontrols.tooltip.controller_type"));
+        this.deadZoneOption = new SpruceDoubleOption("lambdacontrols.menu.dead_zone", 0.05, 1.0, 0.05F, this.mod.config::getDeadZone,
+                newValue -> {
+                    synchronized (this.mod.config) {
+                        this.mod.config.setDeadZone(newValue);
+                    }
+                }, option -> {
+            String value = String.valueOf(option.get());
+            return option.getDisplayText(new LiteralText(value.substring(0, Math.min(value.length(), 5))));
+        }, new TranslatableText("lambdacontrols.tooltip.dead_zone"));
+        this.invertsRightXAxis = new SpruceBooleanOption("lambdacontrols.menu.invert_right_x_axis", this.mod.config::doesInvertRightXAxis,
+                newValue -> {
+                    synchronized (this.mod.config) {
+                        this.mod.config.setInvertRightXAxis(newValue);
+                    }
+                }, null, true);
+        this.invertsRightYAxis = new SpruceBooleanOption("lambdacontrols.menu.invert_right_y_axis", this.mod.config::doesInvertRightYAxis,
+                newValue -> {
+                    synchronized (this.mod.config) {
+                        this.mod.config.setInvertRightYAxis(newValue);
+                    }
+                }, null, true);
+        this.unfocusedInputOption = new SpruceBooleanOption("lambdacontrols.menu.unfocused_input", this.mod.config::hasUnfocusedInput,
+                this.mod.config::setUnfocusedInput, new TranslatableText("lambdacontrols.tooltip.unfocused_input"), true);
+        this.virtualMouseOption = new SpruceBooleanOption("lambdacontrols.menu.virtual_mouse", this.mod.config::hasVirtualMouse,
+                this.mod.config::setVirtualMouse, new TranslatableText("lambdacontrols.tooltip.virtual_mouse"), true);
+        this.virtualMouseSkinOption = new SpruceCyclingOption("lambdacontrols.menu.virtual_mouse.skin",
+                amount -> this.mod.config.setVirtualMouseSkin(this.mod.config.getVirtualMouseSkin().next()),
+                option -> option.getDisplayText(this.mod.config.getVirtualMouseSkin().getTranslatedText()),
+                null);
+        // HUD options
+        this.hudEnableOption = new SpruceBooleanOption("lambdacontrols.menu.hud_enable", this.mod.config::isHudEnabled,
+                this.mod::setHudEnabled, new TranslatableText("lambdacontrols.tooltip.hud_enable"), true);
+        this.hudSideOption = new SpruceCyclingOption("lambdacontrols.menu.hud_side",
+                amount -> this.mod.config.setHudSide(this.mod.config.getHudSide().next()),
+                option -> option.getDisplayText(this.mod.config.getHudSide().getTranslatedText()),
+                new TranslatableText("lambdacontrols.tooltip.hud_side"));
+    }
+
+    @Override
+    public void removed()
+    {
+        this.mod.config.save();
+        super.removed();
+    }
+
+    @Override
+    public void onClose()
+    {
+        this.mod.config.save();
+        super.onClose();
+    }
+
+    private int getTextHeight()
+    {
+        return (5 + this.textRenderer.fontHeight) * 3 + 5;
+    }
+
+    @Override
+    protected void init()
+    {
+        super.init();
+        int buttonHeight = 20;
+        SpruceButtonWidget controlsModeBtn = new SpruceButtonWidget(this.width / 2 - 155, 18, this.hideControls ? 310 : 150, buttonHeight,
+                new TranslatableText("lambdacontrols.menu.controls_mode").append(": ").append(new TranslatableText(this.mod.config.getControlsMode().getTranslationKey())),
+                btn -> {
+                    ControlsMode next = this.mod.config.getControlsMode().next();
+                    btn.setMessage(new TranslatableText("lambdacontrols.menu.controls_mode").append(": ").append(new TranslatableText(next.getTranslationKey())));
+                    this.mod.config.setControlsMode(next);
+                    this.mod.config.save();
+
+                    if (this.client.player != null) {
+                        ClientSidePacketRegistry.INSTANCE.sendToServer(LambdaControls.CONTROLS_MODE_CHANNEL, this.mod.makeControlsModeBuffer(next));
+                    }
+                });
+        controlsModeBtn.setTooltip(new TranslatableText("lambdacontrols.tooltip.controls_mode"));
+        this.addButton(controlsModeBtn);
+        if (!this.hideControls)
+            this.addButton(new ButtonWidget(this.width / 2 - 155 + 160, 18, 150, buttonHeight, new TranslatableText("options.controls"),
+                    btn -> {
+                        if (this.mod.config.getControlsMode() == ControlsMode.CONTROLLER)
+                            this.client.openScreen(new ControllerControlsScreen(this, true));
+                        else
+                            this.client.openScreen(new ControlsOptionsScreen(this, this.client.options));
+                    }));
+
+        this.list = new ButtonListWidget(this.client, this.width, this.height, 43, this.height - 29 - this.getTextHeight(), 25);
+        // General options
+        this.list.addSingleOptionEntry(new SpruceSeparatorOption("lambdacontrols.menu.title.general", true, null));
+        this.list.addOptionEntry(this.rotationSpeedOption, this.mouseSpeedOption);
+        this.list.addSingleOptionEntry(this.autoSwitchModeOption);
+        // Gameplay options
+        this.list.addSingleOptionEntry(new SpruceSeparatorOption("lambdacontrols.menu.title.gameplay", true, null));
+        this.list.addOptionEntry(this.autoJumpOption, this.fastBlockPlacingOption);
+        this.list.addOptionEntry(this.frontBlockPlacingOption, this.verticalReacharoundOption);
+        this.list.addSingleOptionEntry(this.flyDriftingOption);
+        this.list.addSingleOptionEntry(this.flyVerticalDriftingOption);
+        // Controller options
+        this.list.addSingleOptionEntry(new SpruceSeparatorOption("lambdacontrols.menu.title.controller", true, null));
+        this.list.addSingleOptionEntry(this.controllerOption);
+        this.list.addSingleOptionEntry(this.secondControllerOption);
+        this.list.addOptionEntry(this.controllerTypeOption, this.deadZoneOption);
+        this.list.addOptionEntry(this.invertsRightXAxis, this.invertsRightYAxis);
+        this.list.addOptionEntry(this.unfocusedInputOption, this.virtualMouseOption);
+        this.list.addSingleOptionEntry(this.virtualMouseSkinOption);
+        this.list.addSingleOptionEntry(new ReloadControllerMappingsOption());
+        // HUD options
+        this.list.addSingleOptionEntry(new SpruceSeparatorOption("lambdacontrols.menu.title.hud", true, null));
+        this.list.addOptionEntry(this.hudEnableOption, this.hudSideOption);
+        this.children.add(this.list);
+
+        this.gamepadToolUrlLabel = new SpruceLabelWidget(this.width / 2, this.height - 29 - (5 + this.textRenderer.fontHeight) * 2, this.controllerMappingsUrlText, this.width,
+                label -> Util.getOperatingSystem().open(GAMEPAD_TOOL_URL), true);
+        this.gamepadToolUrlLabel.setTooltip(new TranslatableText("chat.link.open"));
+        this.children.add(this.gamepadToolUrlLabel);
+
+        this.addButton(this.resetOption.createButton(this.client.options, this.width / 2 - 155, this.height - 29, 150));
+        this.addButton(new ButtonWidget(this.width / 2 - 155 + 160, this.height - 29, 150, buttonHeight, SpruceTexts.GUI_DONE,
+                (buttonWidget) -> this.client.openScreen(this.parent)));
+    }
+
+    @Override
+    public void render(MatrixStack matrices, int mouseX, int mouseY, float delta)
+    {
+        this.renderBackground(matrices);
+        this.list.render(matrices, mouseX, mouseY, delta);
+        super.render(matrices, mouseX, mouseY, delta);
+        this.drawCenteredString(matrices, this.textRenderer, I18n.translate("lambdacontrols.menu.title"), this.width / 2, 8, 16777215);
+        this.drawCenteredString(matrices, this.textRenderer, I18n.translate("lambdacontrols.controller.mappings.1", Formatting.GREEN.toString(), Formatting.RESET.toString()), this.width / 2, this.height - 29 - (5 + this.textRenderer.fontHeight) * 3, 10526880);
+        this.gamepadToolUrlLabel.render(matrices, mouseX, mouseY, delta);
+        this.drawCenteredString(matrices, this.textRenderer, I18n.translate("lambdacontrols.controller.mappings.3", Formatting.GREEN.toString(), Formatting.RESET.toString()), this.width / 2, this.height - 29 - (5 + this.textRenderer.fontHeight), 10526880);
+
+        Tooltip.renderAll(matrices);
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/gui/ReloadControllerMappingsOption.java

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2019 LambdAurora <aurora42lambda@gmail.com>
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
  *
  * This file is part of LambdaControls.
  *
@@ -7,12 +7,12 @@
  * see the LICENSE file.
  */
 
-package me.lambdaurora.lambdacontrols.gui;
+package me.lambdaurora.lambdacontrols.client.gui;
 
-import me.lambdaurora.lambdacontrols.Controller;
+import me.lambdaurora.lambdacontrols.client.controller.Controller;
+import me.lambdaurora.spruceui.SpruceButtonWidget;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.gui.widget.AbstractButtonWidget;
-import net.minecraft.client.gui.widget.ButtonWidget;
 import net.minecraft.client.options.GameOptions;
 import net.minecraft.client.options.Option;
 import net.minecraft.client.resource.language.I18n;
@@ -36,17 +36,19 @@ public class ReloadControllerMappingsOption extends Option implements Nameable
     @Override
     public AbstractButtonWidget createButton(GameOptions options, int x, int y, int width)
     {
-        return new ButtonWidget(x, y, width, 20, this.get_name(), btn -> {
+        SpruceButtonWidget button = new SpruceButtonWidget(x, y, width, 20, new TranslatableText(KEY), btn -> {
             MinecraftClient client = MinecraftClient.getInstance();
-            Controller.update_mappings();
+            Controller.updateMappings();
             if (client.currentScreen != null)
                 client.currentScreen.init(client, client.getWindow().getScaledWidth(), client.getWindow().getScaledHeight());
             client.getToastManager().add(new SystemToast(SystemToast.Type.TUTORIAL_HINT, new TranslatableText("lambdacontrols.controller.mappings.updated"), null));
         });
+        button.setTooltip(new TranslatableText("lambdacontrols.tooltip.reload_controller_mappings"));
+        return button;
     }
 
     @Override
-    public @NotNull String get_name()
+    public @NotNull String getName()
     {
         return I18n.translate(KEY);
     }

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/gui/TouchscreenOverlay.java

@@ -0,0 +1,297 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.gui;
+
+import me.lambdaurora.lambdacontrols.client.HudSide;
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import me.lambdaurora.lambdacontrols.client.util.KeyBindingAccessor;
+import me.lambdaurora.spruceui.SpruceTexturedButtonWidget;
+import net.minecraft.client.gui.screen.ChatScreen;
+import net.minecraft.client.gui.screen.GameMenuScreen;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.screen.ingame.InventoryScreen;
+import net.minecraft.client.gui.widget.ButtonWidget;
+import net.minecraft.client.gui.widget.TexturedButtonWidget;
+import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket;
+import net.minecraft.text.LiteralText;
+import net.minecraft.util.Arm;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Direction;
+import org.jetbrains.annotations.NotNull;
+import org.lwjgl.glfw.GLFW;
+
+import static org.lwjgl.glfw.GLFW.GLFW_GAMEPAD_AXIS_RIGHT_X;
+import static org.lwjgl.glfw.GLFW.GLFW_GAMEPAD_AXIS_RIGHT_Y;
+
+/**
+ * Represents the touchscreen overlay
+ */
+public class TouchscreenOverlay extends Screen
+{
+    public static final Identifier                 WIDGETS_LOCATION     = new Identifier("lambdacontrols", "textures/gui/widgets.png");
+    private             LambdaControlsClient       mod;
+    private             SpruceTexturedButtonWidget jumpButton;
+    private             SpruceTexturedButtonWidget flyButton;
+    private             SpruceTexturedButtonWidget flyUpButton;
+    private             SpruceTexturedButtonWidget flyDownButton;
+    private             int                        flyButtonEnableTicks = 0;
+    private             int                        forwardButtonTick    = 0;
+    private             SpruceTexturedButtonWidget forwardLeftButton;
+    private             SpruceTexturedButtonWidget forwardRightButton;
+    private             SpruceTexturedButtonWidget startSneakButton;
+    private             SpruceTexturedButtonWidget endSneakButton;
+
+    public TouchscreenOverlay(@NotNull LambdaControlsClient mod)
+    {
+        super(new LiteralText("Touchscreen overlay"));
+        this.mod = mod;
+        this.passEvents = true;
+    }
+
+    @Override
+    public boolean isPauseScreen()
+    {
+        return false;
+    }
+
+    @Override
+    public boolean keyPressed(int keyCode, int scanCode, int modifiers)
+    {
+        return false;
+    }
+
+    private void pauseGame(boolean bl)
+    {
+        if (this.client == null)
+            return;
+        boolean bl2 = this.client.isIntegratedServerRunning() && !this.client.getServer().isRemote();
+        if (bl2) {
+            this.client.openScreen(new GameMenuScreen(!bl));
+            this.client.getSoundManager().pauseAll();
+        } else {
+            this.client.openScreen(new GameMenuScreen(true));
+        }
+    }
+
+    /**
+     * Updates the forward button ticks cooldown.
+     *
+     * @param state The button state.
+     */
+    private void updateForwardButtonsState(boolean state)
+    {
+        if (state)
+            this.forwardButtonTick = -1;
+        else
+            this.forwardButtonTick = 20;
+    }
+
+    /**
+     * Updates the jump buttons.
+     */
+    private void updateJumpButtons()
+    {
+        if (this.client == null)
+            return;
+        if (this.client.player.abilities.allowFlying && this.client.player.abilities.flying) {
+            boolean oldStateFly = this.flyButton.visible;
+            this.jumpButton.visible = false;
+            this.flyButton.visible = true;
+            this.flyUpButton.visible = true;
+            this.flyDownButton.visible = true;
+            if (oldStateFly != this.flyButton.visible) {
+                this.flyButtonEnableTicks = 5;
+                this.handleJump(null, false);
+            } else if (this.flyButtonEnableTicks > 0)
+                this.flyButtonEnableTicks--;
+        } else {
+            this.jumpButton.visible = true;
+            this.flyButton.visible = false;
+            this.flyUpButton.visible = false;
+            this.flyDownButton.visible = false;
+        }
+    }
+
+    /**
+     * Handles the jump button.
+     *
+     * @param btn   The pressed button.
+     * @param state The state of the jump button.
+     */
+    private void handleJump(ButtonWidget btn, boolean state)
+    {
+        ((KeyBindingAccessor) this.client.options.keyJump).lambdacontrols_handlePressState(state);
+    }
+
+    @Override
+    public void tick()
+    {
+        if (this.forwardButtonTick > 0) {
+            this.forwardButtonTick--;
+        } else if (this.forwardButtonTick == 0) {
+            if (this.forwardLeftButton.visible)
+                this.forwardLeftButton.visible = false;
+            if (this.forwardRightButton.visible)
+                this.forwardRightButton.visible = false;
+        }
+        this.updateJumpButtons();
+    }
+
+    @Override
+    protected void init()
+    {
+        super.init();
+        int scaledWidth = this.client.getWindow().getScaledWidth();
+        int scaledHeight = this.client.getWindow().getScaledHeight();
+        this.addButton(new TexturedButtonWidget(scaledWidth / 2 - 20, 0, 20, 20, 0, 106, 20, ButtonWidget.WIDGETS_LOCATION, 256, 256,
+                btn -> this.client.openScreen(new ChatScreen("")), LiteralText.EMPTY));
+        this.addButton(new TexturedButtonWidget(scaledWidth / 2, 0, 20, 20, 0, 0, 20, WIDGETS_LOCATION, 256, 256,
+                btn -> this.pauseGame(false)));
+        // Inventory buttons.
+        int inventoryButtonX = scaledWidth / 2;
+        int inventoryButtonY = scaledHeight - 16 - 5;
+        if (this.client.options.mainArm == Arm.LEFT) {
+            inventoryButtonX = inventoryButtonX - 91 - 24;
+        } else {
+            inventoryButtonX = inventoryButtonX + 91 + 4;
+        }
+        this.addButton(new TexturedButtonWidget(inventoryButtonX, inventoryButtonY, 20, 20, 20, 0, 20, WIDGETS_LOCATION, 256, 256,
+                btn -> {
+                    if (this.client.interactionManager.hasRidingInventory()) {
+                        this.client.player.openRidingInventory();
+                    } else {
+                        this.client.getTutorialManager().onInventoryOpened();
+                        this.client.openScreen(new InventoryScreen(this.client.player));
+                    }
+                }));
+        int jumpButtonX, swapHandsX, sneakButtonX;
+        int sneakButtonY = scaledHeight - 10 - 40 - 5;
+        if (this.mod.config.getHudSide() == HudSide.LEFT) {
+            jumpButtonX = scaledWidth - 20 - 20;
+            swapHandsX = jumpButtonX - 5 - 40;
+            sneakButtonX = 10 + 20 + 5;
+        } else {
+            jumpButtonX = 20;
+            swapHandsX = jumpButtonX + 5 + 40;
+            sneakButtonX = scaledWidth - 10 - 40 - 5;
+        }
+        // Swap items hand.
+        this.addButton(new SpruceTexturedButtonWidget(swapHandsX, sneakButtonY, 20, 20, 0, 160, 20, WIDGETS_LOCATION,
+                (btn, state) -> {
+                    if (state) {
+                        if (!this.client.player.isSpectator()) {
+                            this.client.getNetworkHandler().sendPacket(new PlayerActionC2SPacket(PlayerActionC2SPacket.Action.SWAP_ITEM_WITH_OFFHAND, BlockPos.ORIGIN, Direction.DOWN));
+                        }
+                    }
+                }));
+        // Drop
+        this.addButton(new SpruceTexturedButtonWidget(swapHandsX, sneakButtonY + 5 + 20, 20, 20, 20, 160, 20, WIDGETS_LOCATION,
+                (btn, state) -> ((KeyBindingAccessor) this.client.options.keyDrop).lambdacontrols_handlePressState(state)));
+        // Jump keys
+        this.addButton(this.jumpButton = new SpruceTexturedButtonWidget(jumpButtonX, sneakButtonY, 20, 20, 0, 40, 20, WIDGETS_LOCATION,
+                this::handleJump));
+        this.addButton(this.flyButton = new SpruceTexturedButtonWidget(jumpButtonX, sneakButtonY, 20, 20, 20, 40, 20, WIDGETS_LOCATION,
+                (btn, state) -> {
+                    if (this.flyButtonEnableTicks == 0) this.client.player.abilities.flying = false;
+                }));
+        this.addButton(this.flyUpButton = new SpruceTexturedButtonWidget(jumpButtonX, sneakButtonY - 5 - 20, 20, 20, 40, 40, 20, WIDGETS_LOCATION,
+                this::handleJump));
+        this.addButton(this.flyDownButton = new SpruceTexturedButtonWidget(jumpButtonX, sneakButtonY + 20 + 5, 20, 20, 60, 40, 20, WIDGETS_LOCATION,
+                (btn, state) -> ((KeyBindingAccessor) this.client.options.keySneak).lambdacontrols_handlePressState(state)));
+        this.updateJumpButtons();
+        // Movements keys
+        this.addButton((this.startSneakButton = new SpruceTexturedButtonWidget(sneakButtonX, sneakButtonY, 20, 20, 0, 120, 20, WIDGETS_LOCATION,
+                (btn, state) -> {
+                    if (state) {
+                        ((KeyBindingAccessor) this.client.options.keySneak).lambdacontrols_handlePressState(true);
+                        this.startSneakButton.visible = false;
+                        this.endSneakButton.visible = true;
+                    }
+                })));
+        this.addButton((this.endSneakButton = new SpruceTexturedButtonWidget(sneakButtonX, sneakButtonY, 20, 20, 20, 120, 20, WIDGETS_LOCATION,
+                (btn, state) -> {
+                    if (state) {
+                        ((KeyBindingAccessor) this.client.options.keySneak).lambdacontrols_handlePressState(false);
+                        this.endSneakButton.visible = false;
+                        this.startSneakButton.visible = true;
+                    }
+                })));
+        this.endSneakButton.visible = false;
+        this.addButton(this.forwardLeftButton = new SpruceTexturedButtonWidget(sneakButtonX - 20 - 5, sneakButtonY - 5 - 20, 20, 20, 80, 80, 20, WIDGETS_LOCATION,
+                (btn, state) -> {
+                    ((KeyBindingAccessor) this.client.options.keyForward).lambdacontrols_handlePressState(state);
+                    ((KeyBindingAccessor) this.client.options.keyLeft).lambdacontrols_handlePressState(state);
+                    this.updateForwardButtonsState(state);
+                }));
+        this.forwardLeftButton.visible = false;
+        this.addButton(new SpruceTexturedButtonWidget(sneakButtonX, sneakButtonY - 5 - 20, 20, 20, 0, 80, 20, WIDGETS_LOCATION,
+                (btn, state) -> {
+                    ((KeyBindingAccessor) this.client.options.keyForward).lambdacontrols_handlePressState(state);
+                    this.updateForwardButtonsState(state);
+                    this.forwardLeftButton.visible = true;
+                    this.forwardRightButton.visible = true;
+                }));
+        this.addButton(this.forwardRightButton = new SpruceTexturedButtonWidget(sneakButtonX + 20 + 5, sneakButtonY - 5 - 20, 20, 20, 100, 80, 20, WIDGETS_LOCATION,
+                (btn, state) -> {
+                    ((KeyBindingAccessor) this.client.options.keyForward).lambdacontrols_handlePressState(state);
+                    ((KeyBindingAccessor) this.client.options.keyRight).lambdacontrols_handlePressState(state);
+                    this.updateForwardButtonsState(state);
+                }));
+        this.forwardRightButton.visible = true;
+        this.addButton(new SpruceTexturedButtonWidget(sneakButtonX + 20 + 5, sneakButtonY, 20, 20, 20, 80, 20, WIDGETS_LOCATION,
+                (btn, state) -> ((KeyBindingAccessor) this.client.options.keyRight).lambdacontrols_handlePressState(state)));
+        this.addButton(new SpruceTexturedButtonWidget(sneakButtonX, sneakButtonY + 20 + 5, 20, 20, 40, 80, 20, WIDGETS_LOCATION,
+                (btn, state) -> ((KeyBindingAccessor) this.client.options.keyBack).lambdacontrols_handlePressState(state)));
+        this.addButton(new SpruceTexturedButtonWidget(sneakButtonX - 20 - 5, sneakButtonY, 20, 20, 60, 80, 20, WIDGETS_LOCATION,
+                (btn, state) -> ((KeyBindingAccessor) this.client.options.keyLeft).lambdacontrols_handlePressState(state)));
+
+        this.buttons.forEach(button -> {
+            if (button instanceof SpruceTexturedButtonWidget) {
+                ((SpruceTexturedButtonWidget) button).setSilent(true);
+            }
+        });
+    }
+
+    @Override
+    public boolean mouseClicked(double mouseX, double mouseY, int button)
+    {
+        if (mouseY >= (double) (this.height - 22) && this.client != null && this.client.player != null) {
+            int centerX = this.width / 2;
+            if (mouseX >= (double) (centerX - 90) && mouseX <= (double) (centerX + 90)) {
+                for (int slot = 0; slot < 9; ++slot) {
+                    int slotX = centerX - 90 + slot * 20 + 2;
+                    if (mouseX >= (double) slotX && mouseX <= (double) (slotX + 20)) {
+                        this.client.player.inventory.selectedSlot = slot;
+                        return true;
+                    }
+                }
+            }
+        }
+        return super.mouseClicked(mouseX, mouseY, button);
+    }
+
+    @Override
+    public boolean mouseDragged(double mouseX, double mouseY, int button, double deltaX, double deltaY)
+    {
+        if (button == GLFW.GLFW_MOUSE_BUTTON_1 && this.client != null) {
+            if (deltaY > 0.01)
+                this.mod.input.handleLook(this.client, GLFW_GAMEPAD_AXIS_RIGHT_Y, (float) Math.abs(deltaY / 5.0), 2);
+            else if (deltaY < 0.01)
+                this.mod.input.handleLook(this.client, GLFW_GAMEPAD_AXIS_RIGHT_Y, (float) Math.abs(deltaY / 5.0), 1);
+
+            if (deltaX > 0.01)
+                this.mod.input.handleLook(this.client, GLFW_GAMEPAD_AXIS_RIGHT_X, (float) Math.abs(deltaX / 5.0), 2);
+            else if (deltaX < 0.01)
+                this.mod.input.handleLook(this.client, GLFW_GAMEPAD_AXIS_RIGHT_X, (float) Math.abs(deltaX / 5.0), 1);
+        }
+        return super.mouseDragged(mouseX, mouseY, button, deltaX, deltaY);
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/mixin/AbstractButtonWidgetAccessor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2019 LambdAurora <aurora42lambda@gmail.com>
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
  *
  * This file is part of LambdaControls.
  *
@@ -7,7 +7,7 @@
  * see the LICENSE file.
  */
 
-package me.lambdaurora.lambdacontrols.mixin;
+package me.lambdaurora.lambdacontrols.client.mixin;
 
 import net.minecraft.client.gui.widget.AbstractButtonWidget;
 import org.spongepowered.asm.mixin.Mixin;
@@ -17,5 +17,5 @@ import org.spongepowered.asm.mixin.gen.Accessor;
 public interface AbstractButtonWidgetAccessor
 {
     @Accessor("height")
-    int get_height();
+    int getHeight();
 }

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/mixin/AdvancementsScreenAccessor.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.mixin;
+
+import net.minecraft.advancement.Advancement;
+import net.minecraft.client.gui.screen.advancement.AdvancementTab;
+import net.minecraft.client.gui.screen.advancement.AdvancementsScreen;
+import net.minecraft.client.network.ClientAdvancementManager;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+import java.util.Map;
+
+/**
+ * Represents an accessor of {@link AdvancementsScreen}.
+ */
+@Mixin(AdvancementsScreen.class)
+public interface AdvancementsScreenAccessor
+{
+    @Accessor("advancementHandler")
+    ClientAdvancementManager getAdvancementManager();
+
+    @Accessor("tabs")
+    Map<Advancement, AdvancementTab> getTabs();
+
+    @Accessor("selectedTab")
+    AdvancementTab getSelectedTab();
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/mixin/ClientPlayNetworkHandlerMixin.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.mixin;
+
+import me.lambdaurora.lambdacontrols.LambdaControls;
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import net.fabricmc.fabric.api.network.ClientSidePacketRegistry;
+import net.minecraft.client.network.ClientPlayNetworkHandler;
+import net.minecraft.network.packet.s2c.play.GameJoinS2CPacket;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(ClientPlayNetworkHandler.class)
+public class ClientPlayNetworkHandlerMixin
+{
+    @Inject(method = "onGameJoin", at = @At(value = "TAIL"))
+    private void onGameJoin(GameJoinS2CPacket packet, CallbackInfo ci)
+    {
+        ClientSidePacketRegistry.INSTANCE.sendToServer(LambdaControls.HELLO_CHANNEL, LambdaControls.get().makeHello(LambdaControlsClient.get().config.getControlsMode()));
+        ClientSidePacketRegistry.INSTANCE.sendToServer(LambdaControls.CONTROLS_MODE_CHANNEL,
+                LambdaControls.get().makeControlsModeBuffer(LambdaControlsClient.get().config.getControlsMode()));
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/mixin/ClientPlayerEntityMixin.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.mixin;
+
+import com.mojang.authlib.GameProfile;
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import me.lambdaurora.lambdacontrols.client.controller.MovementHandler;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.input.Input;
+import net.minecraft.client.network.AbstractClientPlayerEntity;
+import net.minecraft.client.network.ClientPlayerEntity;
+import net.minecraft.client.world.ClientWorld;
+import net.minecraft.entity.MovementType;
+import net.minecraft.util.math.Vec3d;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+/**
+ * Injects the anti fly drifting feature.
+ */
+@Mixin(ClientPlayerEntity.class)
+public abstract class ClientPlayerEntityMixin extends AbstractClientPlayerEntity
+{
+    private boolean lambdacontrols_driftingPrevented = false;
+
+    @Shadow
+    protected abstract boolean hasMovementInput();
+
+    @Shadow
+    @Final
+    protected MinecraftClient client;
+
+    @Shadow
+    public Input input;
+
+    @Shadow
+    protected abstract boolean isCamera();
+
+    public ClientPlayerEntityMixin(ClientWorld world, GameProfile profile)
+    {
+        super(world, profile);
+    }
+
+    @Inject(method = "move(Lnet/minecraft/entity/MovementType;Lnet/minecraft/util/math/Vec3d;)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/network/AbstractClientPlayerEntity;move(Lnet/minecraft/entity/MovementType;Lnet/minecraft/util/math/Vec3d;)V"))
+    public void onMove(MovementType type, Vec3d movement, CallbackInfo ci)
+    {
+        LambdaControlsClient mod = LambdaControlsClient.get();
+        if (type == MovementType.SELF) {
+            if (this.abilities.flying && (!mod.config.hasFlyDrifting() || !mod.config.hasFlyVerticalDrifting())) {
+                if (!this.hasMovementInput()) {
+                    if (!this.lambdacontrols_driftingPrevented) {
+                        if (!mod.config.hasFlyDrifting())
+                            this.setVelocity(this.getVelocity().multiply(0, 1.0, 0));
+                    }
+                    this.lambdacontrols_driftingPrevented = true;
+                } else
+                    this.lambdacontrols_driftingPrevented = false;
+            }
+        }
+    }
+
+    @Inject(method = "tickMovement", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/input/Input;tick(Z)V", shift = At.Shift.AFTER))
+    public void onInputUpdate(CallbackInfo ci)
+    {
+        MovementHandler.HANDLER.applyMovement((ClientPlayerEntity) (Object) this);
+    }
+
+    @Inject(method = "tickMovement", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/network/ClientPlayerEntity;isCamera()Z"))
+    public void onTickMovement(CallbackInfo ci)
+    {
+        if (this.abilities.flying && this.isCamera()) {
+            if (LambdaControlsClient.get().config.hasFlyVerticalDrifting())
+                return;
+            int moving = 0;
+            if (this.input.sneaking) {
+                --moving;
+            }
+
+            if (this.input.jumping) {
+                ++moving;
+            }
+
+            if (moving == 0) {
+                this.setVelocity(this.getVelocity().multiply(1.0, 0.0, 1.0));
+            }
+        }
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/mixin/ControlsOptionsScreenMixin.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.mixin;
+
+import me.lambdaurora.lambdacontrols.client.gui.ControllerControlsScreen;
+import me.lambdaurora.lambdacontrols.client.gui.LambdaControlsSettingsScreen;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.screen.options.ControlsOptionsScreen;
+import net.minecraft.client.gui.screen.options.GameOptionsScreen;
+import net.minecraft.client.gui.widget.AbstractButtonWidget;
+import net.minecraft.client.gui.widget.ButtonWidget;
+import net.minecraft.client.options.GameOptions;
+import net.minecraft.text.Text;
+import net.minecraft.text.TranslatableText;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+/**
+ * Injects the new controls settings button.
+ */
+@Mixin(ControlsOptionsScreen.class)
+public class ControlsOptionsScreenMixin extends GameOptionsScreen
+{
+    public ControlsOptionsScreenMixin(Screen parent, GameOptions gameOptions, Text text)
+    {
+        super(parent, gameOptions, text);
+    }
+
+    @Redirect(method = "init", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/gui/screen/options/ControlsOptionsScreen;addButton(Lnet/minecraft/client/gui/widget/AbstractButtonWidget;)Lnet/minecraft/client/gui/widget/AbstractButtonWidget;", ordinal = 1))
+    private AbstractButtonWidget onInit(ControlsOptionsScreen screen, AbstractButtonWidget btn)
+    {
+        if (this.parent instanceof ControllerControlsScreen)
+            return this.addButton(btn);
+        else
+            return this.addButton(new ButtonWidget(btn.x, btn.y, btn.getWidth(), ((AbstractButtonWidgetAccessor) btn).getHeight(), new TranslatableText("menu.options"),
+                    b -> this.client.openScreen(new LambdaControlsSettingsScreen(this, true))));
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/mixin/CreativeInventoryScreenAccessor.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.mixin;
+
+import net.minecraft.client.gui.screen.ingame.CreativeInventoryScreen;
+import net.minecraft.item.ItemGroup;
+import net.minecraft.screen.slot.Slot;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+/**
+ * Represents an accessor to CreativeInventoryScreen.
+ */
+@Mixin(CreativeInventoryScreen.class)
+public interface CreativeInventoryScreenAccessor
+{
+    /**
+     * Gets the selected tab.
+     *
+     * @return The selected tab index.
+     */
+    @Accessor("selectedTab")
+    int getSelectedTab();
+
+    /**
+     * Sets the selected tab.
+     *
+     * @param group The tab's item group.
+     */
+    @Invoker("setSelectedTab")
+    void lambdacontrols_setSelectedTab(@NotNull ItemGroup group);
+
+    /**
+     * Returns whether the slot belongs to the creative inventory or not.
+     *
+     * @param slot The slot to check.
+     * @return True if the slot is from the creative inventory, else false.
+     */
+    @Invoker("isCreativeInventorySlot")
+    boolean lambdacontrols_isCreativeInventorySlot(@Nullable Slot slot);
+
+    /**
+     * Returns whether the current tab has a scrollbar or not.
+     *
+     * @return True if the current tab has a scrollbar, else false.
+     */
+    @Invoker("hasScrollbar")
+    boolean lambdacontrols_hasScrollbar();
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/mixin/EntryListWidgetAccessor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2019 LambdAurora <aurora42lambda@gmail.com>
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
  *
  * This file is part of LambdaControls.
  *
@@ -7,7 +7,7 @@
  * see the LICENSE file.
  */
 
-package me.lambdaurora.lambdacontrols.mixin;
+package me.lambdaurora.lambdacontrols.client.mixin;
 
 import net.minecraft.client.gui.widget.EntryListWidget;
 import org.spongepowered.asm.mixin.Mixin;
@@ -17,5 +17,5 @@ import org.spongepowered.asm.mixin.gen.Invoker;
 public interface EntryListWidgetAccessor
 {
     @Invoker("moveSelection")
-    void move_selection(int amount);
+    void lambdacontrols_moveSelection(EntryListWidget.MoveDirection direction);
 }

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/mixin/GameOptionsMixin.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.mixin;
+
+import net.minecraft.client.options.GameOptions;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+/**
+ * Represents a mixin to GameOptions.
+ * <p>
+ * Sets the default of the Auto-Jump option to false.
+ */
+@Mixin(GameOptions.class)
+public class GameOptionsMixin
+{
+    @Shadow
+    public boolean autoJump;
+
+    @Inject(method = "load", at = @At("HEAD"))
+    public void onInit(CallbackInfo ci)
+    {
+        // Set default value of the Auto-Jump option to false.
+        this.autoJump = false;
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/mixin/GameRendererMixin.java

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2019 LambdAurora <aurora42lambda@gmail.com>
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
  *
  * This file is part of LambdaControls.
  *
@@ -7,10 +7,10 @@
  * see the LICENSE file.
  */
 
-package me.lambdaurora.lambdacontrols.mixin;
+package me.lambdaurora.lambdacontrols.client.mixin;
 
 import me.lambdaurora.lambdacontrols.ControlsMode;
-import me.lambdaurora.lambdacontrols.LambdaControls;
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.render.GameRenderer;
 import org.spongepowered.asm.mixin.Final;
@@ -28,9 +28,9 @@ public class GameRendererMixin
     private MinecraftClient client;
 
     @Inject(method = "render", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/Mouse;getX()D"))
-    private void on_render(float tick_delta, long start_time, boolean full_render, CallbackInfo ci)
+    private void onRender(float tickDelta, long startTime, boolean fullRender, CallbackInfo ci)
     {
-        if (this.client.currentScreen != null && LambdaControls.get().config.get_controls_mode() == ControlsMode.CONTROLLER)
-            LambdaControls.get().input.on_pre_render_screen(this.client, this.client.currentScreen);
+        if (this.client.currentScreen != null && LambdaControlsClient.get().config.getControlsMode() == ControlsMode.CONTROLLER)
+            LambdaControlsClient.get().input.onPreRenderScreen(this.client, this.client.currentScreen);
     }
 }

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/mixin/HandledScreenMixin.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.mixin;
+
+import me.lambdaurora.lambdacontrols.ControlsMode;
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import me.lambdaurora.lambdacontrols.client.compat.LambdaControlsCompat;
+import me.lambdaurora.lambdacontrols.client.gui.LambdaControlsRenderer;
+import me.lambdaurora.lambdacontrols.client.util.HandledScreenAccessor;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.screen.ingame.HandledScreen;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.screen.slot.Slot;
+import net.minecraft.screen.slot.SlotActionType;
+import org.jetbrains.annotations.Nullable;
+import org.lwjgl.glfw.GLFW;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import org.spongepowered.asm.mixin.gen.Invoker;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+/**
+ * Represents the mixin for the class ContainerScreen.
+ */
+@Mixin(HandledScreen.class)
+public abstract class HandledScreenMixin implements HandledScreenAccessor
+{
+    @Accessor("x")
+    public abstract int getX();
+
+    @Accessor("y")
+    public abstract int getY();
+
+    @Invoker("getSlotAt")
+    public abstract Slot lambdacontrols_getSlotAt(double posX, double posY);
+
+    @Invoker("isClickOutsideBounds")
+    public abstract boolean lambdacontrols_isClickOutsideBounds(double mouseX, double mouseY, int x, int y, int button);
+
+    @Invoker("onMouseClick")
+    public abstract void lambdacontrols_onMouseClick(@Nullable Slot slot, int slotId, int clickData, SlotActionType actionType);
+
+    @Inject(method = "render", at = @At("RETURN"))
+    public void onRender(MatrixStack matrices, int mouseX, int mouseY, float delta, CallbackInfo ci)
+    {
+        if (LambdaControlsClient.get().config.getControlsMode() == ControlsMode.CONTROLLER) {
+            MinecraftClient client = MinecraftClient.getInstance();
+            int x = 2, y = client.getWindow().getScaledHeight() - 2 - LambdaControlsRenderer.ICON_SIZE;
+
+            x = LambdaControlsRenderer.drawButtonTip(matrices, x, y, new int[]{GLFW.GLFW_GAMEPAD_BUTTON_A}, "lambdacontrols.action.pickup_all", true, client) + 2;
+            x = LambdaControlsRenderer.drawButtonTip(matrices, x, y, new int[]{GLFW.GLFW_GAMEPAD_BUTTON_B}, "lambdacontrols.action.exit", true, client) + 2;
+            if (LambdaControlsCompat.isReiPresent()) {
+                x = 2;
+                y -= 24;
+            }
+            x = LambdaControlsRenderer.drawButtonTip(matrices, x, y, new int[]{GLFW.GLFW_GAMEPAD_BUTTON_X}, "lambdacontrols.action.pickup", true, client) + 2;
+            LambdaControlsRenderer.drawButtonTip(matrices, x, y, new int[]{GLFW.GLFW_GAMEPAD_BUTTON_Y}, "lambdacontrols.action.quick_move", true, client);
+        }
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/mixin/KeyBindingMixin.java

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2019 LambdAurora <aurora42lambda@gmail.com>
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
  *
  * This file is part of LambdaControls.
  *
@@ -7,41 +7,30 @@
  * see the LICENSE file.
  */
 
-package me.lambdaurora.lambdacontrols.mixin;
+package me.lambdaurora.lambdacontrols.client.mixin;
 
-import me.lambdaurora.lambdacontrols.util.KeyBindingAccessor;
+import me.lambdaurora.lambdacontrols.client.util.KeyBindingAccessor;
 import net.minecraft.client.options.KeyBinding;
-import net.minecraft.client.util.InputUtil;
-import org.jetbrains.annotations.NotNull;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 
 @Mixin(KeyBinding.class)
 public class KeyBindingMixin implements KeyBindingAccessor
 {
-    @Shadow
-    private InputUtil.KeyCode keyCode;
-
     @Shadow
     private int timesPressed;
 
     @Shadow
     private boolean pressed;
 
-    @Override
-    public @NotNull InputUtil.KeyCode get_key_code()
-    {
-        return this.keyCode;
-    }
-
     @Override
     public boolean lambdacontrols_press()
     {
-        boolean old_pressed = this.pressed;
+        boolean oldPressed = this.pressed;
         if (!this.pressed)
             this.pressed = true;
         ++this.timesPressed;
-        return old_pressed != this.pressed;
+        return oldPressed != this.pressed;
     }
 
     @Override

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/mixin/MinecraftClientMixin.java

@@ -0,0 +1,169 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.mixin;
+
+import me.lambdaurora.lambdacontrols.LambdaControlsFeature;
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import me.lambdaurora.lambdacontrols.client.LambdaReacharound;
+import me.lambdaurora.lambdacontrols.client.gui.LambdaControlsRenderer;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.network.ClientPlayerEntity;
+import net.minecraft.client.network.ClientPlayerInteractionManager;
+import net.minecraft.client.render.GameRenderer;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.world.ClientWorld;
+import net.minecraft.item.BlockItem;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.Hand;
+import net.minecraft.util.hit.BlockHitResult;
+import net.minecraft.util.hit.HitResult;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Direction;
+import net.minecraft.util.math.Vec3d;
+import org.jetbrains.annotations.Nullable;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
+
+@Mixin(MinecraftClient.class)
+public abstract class MinecraftClientMixin
+{
+    @Shadow
+    @Nullable
+    public HitResult crosshairTarget;
+
+    @Shadow
+    @Nullable
+    public ClientPlayerEntity player;
+
+    @Shadow
+    @Nullable
+    public ClientPlayerInteractionManager interactionManager;
+
+    @Shadow
+    @Nullable
+    public ClientWorld world;
+
+    @Shadow
+    @Final
+    public GameRenderer gameRenderer;
+
+    @Shadow
+    private int itemUseCooldown;
+
+    private BlockPos  lambdacontrols_lastTargetPos;
+    private Vec3d     lambdacontrols_lastPos;
+    private Direction lambdacontrols_lastTargetSide;
+
+    @Inject(method = "<init>", at = @At("RETURN"))
+    private void onInit(CallbackInfo ci)
+    {
+        LambdaControlsClient.get().onMcInit((MinecraftClient) (Object) this);
+    }
+
+    @Inject(method = "tick", at = @At("HEAD"))
+    private void onStartTick(CallbackInfo ci)
+    {
+        if (this.player == null)
+            return;
+
+        if (!LambdaControlsFeature.FAST_BLOCK_PLACING.isAvailable())
+            return;
+        if (this.lambdacontrols_lastPos == null)
+            this.lambdacontrols_lastPos = this.player.getPos();
+
+        int cooldown = this.itemUseCooldown;
+        BlockHitResult hitResult;
+        if (this.crosshairTarget != null && this.crosshairTarget.getType() == HitResult.Type.BLOCK && this.player.abilities.flying) {
+            hitResult = (BlockHitResult) this.crosshairTarget;
+            BlockPos targetPos = hitResult.getBlockPos();
+            Direction side = hitResult.getSide();
+
+            boolean sidewaysBlockPlacing = this.lambdacontrols_lastTargetPos == null || !targetPos.equals(this.lambdacontrols_lastTargetPos.offset(this.lambdacontrols_lastTargetSide));
+            boolean backwardsBlockPlacing = this.player.input.movementForward < 0.0f && (this.lambdacontrols_lastTargetPos == null || targetPos.equals(this.lambdacontrols_lastTargetPos.offset(this.lambdacontrols_lastTargetSide)));
+
+            if (cooldown > 1
+                    && !targetPos.equals(this.lambdacontrols_lastTargetPos)
+                    && (sidewaysBlockPlacing || backwardsBlockPlacing)) {
+                this.itemUseCooldown = 1;
+            }
+
+            this.lambdacontrols_lastTargetPos = targetPos.toImmutable();
+            this.lambdacontrols_lastTargetSide = side;
+        }
+        // Removed front placing sprinting as way too cheaty.
+        /* else if (this.player.isSprinting()) {
+            hitResult = this.lambdacontrols_frontBlockPlaceResult;
+            if (hitResult != null) {
+                if (cooldown > 0)
+                    this.itemUseCooldown = 0;
+            }
+        } */
+        this.lambdacontrols_lastPos = this.player.getPos();
+    }
+
+    @Inject(method = "render", at = @At("HEAD"))
+    private void onRender(boolean fullRender, CallbackInfo ci)
+    {
+        LambdaControlsClient.get().onRender((MinecraftClient) (Object) (this));
+    }
+
+    @Inject(method = "render", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/GameRenderer;render(FJZ)V", shift = At.Shift.AFTER))
+    private void renderVirtualCursor(boolean fullRender, CallbackInfo ci)
+    {
+        LambdaControlsRenderer.renderVirtualCursor(new MatrixStack(), (MinecraftClient) (Object) this);
+    }
+
+    @Inject(method = "disconnect(Lnet/minecraft/client/gui/screen/Screen;)V", at = @At("RETURN"))
+    private void onLeave(@Nullable Screen screen, CallbackInfo ci)
+    {
+        LambdaControlsClient.get().onLeave();
+    }
+
+    @Inject(method = "doItemUse()V", at = @At(value = "INVOKE", target = "Lnet/minecraft/util/hit/HitResult;getType()Lnet/minecraft/util/hit/HitResult$Type;"), locals = LocalCapture.CAPTURE_FAILEXCEPTION, cancellable = true)
+    private void onItemUse(CallbackInfo ci, Hand[] hands, int handCount, int handIndex, Hand hand, ItemStack stackInHand)
+    {
+        if (!stackInHand.isEmpty() && this.player.pitch > 35.0F && LambdaControlsClient.get().reacharound.isReacharoundAvailable()) {
+            if (this.crosshairTarget != null && this.crosshairTarget.getType() == HitResult.Type.MISS && this.player.isOnGround()) {
+                if (!stackInHand.isEmpty() && stackInHand.getItem() instanceof BlockItem) {
+                    BlockHitResult hitResult = LambdaControlsClient.get().reacharound.getLastReacharoundResult();
+
+                    if (hitResult == null)
+                        return;
+
+                    hitResult = LambdaReacharound.withSideForReacharound(hitResult, stackInHand);
+
+                    int previousStackCount = stackInHand.getCount();
+                    ActionResult result = this.interactionManager.interactBlock(this.player, this.world, hand, hitResult);
+                    if (result.isAccepted()) {
+                        if (result.shouldSwingHand()) {
+                            this.player.swingHand(hand);
+                            if (!stackInHand.isEmpty() && (stackInHand.getCount() != previousStackCount || this.interactionManager.hasCreativeInventory())) {
+                                this.gameRenderer.firstPersonRenderer.resetEquipProgress(hand);
+                            }
+                        }
+
+                        ci.cancel();
+                    }
+
+                    if (result == ActionResult.FAIL) {
+                        ci.cancel();
+                    }
+                }
+            }
+        }
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/mixin/MouseMixin.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.mixin;
+
+import me.lambdaurora.lambdacontrols.ControlsMode;
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import me.lambdaurora.lambdacontrols.client.LambdaControlsConfig;
+import me.lambdaurora.lambdacontrols.client.util.MouseAccessor;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Mouse;
+import org.lwjgl.glfw.GLFW;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.gen.Invoker;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+/**
+ * Adds extra access to the mouse.
+ */
+@Mixin(Mouse.class)
+public abstract class MouseMixin implements MouseAccessor
+{
+    @Shadow
+    @Final
+    private MinecraftClient client;
+
+    @Invoker("onCursorPos")
+    public abstract void lambdacontrols_onCursorPos(long window, double x, double y);
+
+    @Inject(method = "method_1605", at = @At(value = "INVOKE", shift = At.Shift.AFTER, target = "Lnet/minecraft/client/gui/screen/Screen;mouseReleased(DDI)Z"))
+    private void onMouseBackButton(boolean[] result, double mouseX, double mouseY, int button, CallbackInfo ci)
+    {
+        if (!result[0] && button == GLFW.GLFW_MOUSE_BUTTON_4 && this.client.currentScreen != null) {
+            if (LambdaControlsClient.get().input.tryGoBack(this.client.currentScreen)) {
+                result[0] = true;
+            }
+        }
+    }
+
+    @Inject(method = "isCursorLocked", at = @At("HEAD"), cancellable = true)
+    private void isCursorLocked(CallbackInfoReturnable<Boolean> ci)
+    {
+        if (this.client.currentScreen == null) {
+            LambdaControlsConfig config = LambdaControlsClient.get().config;
+            if (config.getControlsMode() == ControlsMode.CONTROLLER && config.hasVirtualMouse()) {
+                ci.setReturnValue(true);
+                ci.cancel();
+            }
+        }
+    }
+
+    @Inject(method = "lockCursor", at = @At("HEAD"), cancellable = true)
+    private void onCursorLocked(CallbackInfo ci)
+    {
+        LambdaControlsConfig config = LambdaControlsClient.get().config;
+        if (config.getControlsMode() == ControlsMode.TOUCHSCREEN
+                || (config.getControlsMode() == ControlsMode.CONTROLLER && config.hasVirtualMouse()))
+            ci.cancel();
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/mixin/OptionsScreenMixin.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.mixin;
+
+import me.lambdaurora.lambdacontrols.ControlsMode;
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import me.lambdaurora.lambdacontrols.client.gui.ControllerControlsScreen;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.screen.options.OptionsScreen;
+import net.minecraft.client.gui.widget.AbstractButtonWidget;
+import net.minecraft.client.gui.widget.ButtonWidget;
+import net.minecraft.text.Text;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+/**
+ * Injects the new controls settings button.
+ */
+@Mixin(OptionsScreen.class)
+public class OptionsScreenMixin extends Screen
+{
+    protected OptionsScreenMixin(Text title)
+    {
+        super(title);
+    }
+
+    @Redirect(method = "init", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/gui/screen/options/OptionsScreen;addButton(Lnet/minecraft/client/gui/widget/AbstractButtonWidget;)Lnet/minecraft/client/gui/widget/AbstractButtonWidget;", ordinal = 7))
+    private AbstractButtonWidget lambdacontrols_onInit(OptionsScreen screen, AbstractButtonWidget btn)
+    {
+        if (LambdaControlsClient.get().config.getControlsMode() == ControlsMode.CONTROLLER) {
+            return this.addButton(new ButtonWidget(btn.x, btn.y, btn.getWidth(), ((AbstractButtonWidgetAccessor) btn).getHeight(), btn.getMessage(),
+                    b -> this.client.openScreen(new ControllerControlsScreen(this, false))));
+        } else {
+            return this.addButton(btn);
+        }
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/mixin/RecipeBookWidgetAccessor.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.mixin;
+
+import net.minecraft.client.gui.screen.recipebook.RecipeBookWidget;
+import net.minecraft.client.gui.screen.recipebook.RecipeGroupButtonWidget;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+import java.util.List;
+
+@Mixin(RecipeBookWidget.class)
+public interface RecipeBookWidgetAccessor
+{
+    @Accessor("tabButtons")
+    List<RecipeGroupButtonWidget> getTabButtons();
+
+    @Accessor("currentTab")
+    RecipeGroupButtonWidget getCurrentTab();
+
+    @Accessor("currentTab")
+    void setCurrentTab(RecipeGroupButtonWidget currentTab);
+
+    @Invoker("refreshResults")
+    void lambdacontrols_refreshResults(boolean resetCurrentPage);
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/mixin/WorldRendererMixin.java

@@ -0,0 +1,105 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.mixin;
+
+import me.lambdaurora.lambdacontrols.client.LambdaControlsClient;
+import me.lambdaurora.lambdacontrols.client.LambdaReacharound;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.ShapeContext;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.render.*;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.world.ClientWorld;
+import net.minecraft.item.BlockItem;
+import net.minecraft.item.ItemPlacementContext;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.ItemUsageContext;
+import net.minecraft.util.Hand;
+import net.minecraft.util.hit.BlockHitResult;
+import net.minecraft.util.hit.HitResult;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Matrix4f;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.shape.VoxelShape;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
+
+/**
+ * Represents a mixin to WorldRenderer.
+ * <p>
+ * Handles the rendering of the block outline of the front block placing.
+ */
+@Mixin(WorldRenderer.class)
+public abstract class WorldRendererMixin
+{
+    @Shadow
+    @Final
+    private MinecraftClient client;
+
+    @Shadow
+    private ClientWorld world;
+
+    @Shadow
+    @Final
+    private BufferBuilderStorage bufferBuilders;
+
+    @Shadow
+    private static void drawShapeOutline(MatrixStack matrixStack, VertexConsumer vertexConsumer, VoxelShape voxelShape, double d, double e, double f, float g, float h, float i, float j)
+    {
+    }
+
+    @Inject(
+            method = "render",
+            at = @At(
+                    value = "FIELD",
+                    target = "Lnet/minecraft/client/MinecraftClient;crosshairTarget:Lnet/minecraft/util/hit/HitResult;",
+                    ordinal = 1,
+                    shift = At.Shift.AFTER
+            )
+    )
+    private void onOutlineRender(MatrixStack matrices, float tickDelta, long limitTime, boolean renderBlockOutline, Camera camera, GameRenderer gameRenderer,
+                                 LightmapTextureManager lightmapTextureManager, Matrix4f matrix4f, CallbackInfo ci)
+    {
+        if (this.client.crosshairTarget == null || this.client.crosshairTarget.getType() != HitResult.Type.MISS || !LambdaControlsClient.get().config.shouldRenderReacharoundOutline())
+            return;
+        BlockHitResult result = LambdaControlsClient.get().reacharound.getLastReacharoundResult();
+        if (result == null)
+            return;
+        BlockPos blockPos = result.getBlockPos();
+        if (this.world.getWorldBorder().contains(blockPos)) {
+            ItemStack stack = this.client.player.getStackInHand(Hand.MAIN_HAND);
+            if (stack == null || !(stack.getItem() instanceof BlockItem))
+                return;
+
+            Block block = ((BlockItem) stack.getItem()).getBlock();
+            result = LambdaReacharound.withSideForReacharound(result, block);
+            ItemPlacementContext context = new ItemPlacementContext(new ItemUsageContext(this.client.player, Hand.MAIN_HAND, result));
+
+            BlockState placementState = block.getPlacementState(context);
+            if (placementState == null)
+                return;
+            Vec3d pos = camera.getPos();
+
+            VoxelShape outlineShape = placementState.getOutlineShape(this.client.world, blockPos, ShapeContext.of(camera.getFocusedEntity()));
+            int[] color = LambdaControlsClient.get().config.getReacharoundOutlineColor();
+
+            VertexConsumer vertexConsumer = this.bufferBuilders.getEntityVertexConsumers().getBuffer(RenderLayer.getLines());
+            drawShapeOutline(matrices, vertexConsumer, outlineShape,
+                    (double) blockPos.getX() - pos.getX(), (double) blockPos.getY() - pos.getY(), (double) blockPos.getZ() - pos.getZ(),
+                    color[0] / 255.f, color[1] / 255.f, color[2] / 255.f, color[3] / 255.f);
+        }
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/ring/KeyBindingRingAction.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.ring;
+
+import me.lambdaurora.lambdacontrols.client.util.KeyBindingAccessor;
+import net.minecraft.client.options.KeyBinding;
+import org.jetbrains.annotations.NotNull;
+
+public class KeyBindingRingAction extends RingAction
+{
+    public final KeyBinding binding;
+
+    public KeyBindingRingAction(@NotNull KeyBinding binding)
+    {
+        this.binding = binding;
+    }
+
+    @Override
+    public @NotNull String getName()
+    {
+        return this.binding.getTranslationKey();
+    }
+
+    @Override
+    public void onAction(@NotNull RingButtonMode mode)
+    {
+        KeyBindingAccessor accessor = (KeyBindingAccessor) this.binding;
+        switch (mode) {
+            case PRESS:
+            case HOLD:
+                accessor.lambdacontrols_handlePressState(this.activated);
+                break;
+            case TOGGLE:
+                accessor.lambdacontrols_handlePressState(!this.binding.isPressed());
+                this.activated = !this.binding.isPressed();
+                break;
+        }
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/ring/LambdaRing.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.ring;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Represents a key binding ring.
+ *
+ * @author LambdAurora
+ * @version 1.4.0
+ * @since 1.4.0
+ */
+public class LambdaRing
+{
+    private final List<RingPage> pages       = new ArrayList<>(Collections.singletonList(new RingPage()));
+    private       int            currentPage = 0;
+
+    public LambdaRing()
+    {
+    }
+
+    public @NotNull RingPage getCurrentPage()
+    {
+        if (this.currentPage >= this.pages.size())
+            this.currentPage = this.pages.size() - 1;
+        else if (this.currentPage < 0)
+            this.currentPage = 0;
+        return this.pages.get(this.currentPage);
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/ring/RingAction.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.ring;
+
+import net.minecraft.text.TranslatableText;
+import org.aperlambda.lambdacommon.utils.Nameable;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Represents a ring action.
+ *
+ * @author LambdAurora
+ * @version 1.4.0
+ * @since 1.4.0
+ */
+public abstract class RingAction implements Nameable
+{
+    protected boolean activated = false;
+
+    /**
+     * Gets the translated name of the ring action.
+     *
+     * @return The translated name.
+     */
+    public TranslatableText getTranslatedName()
+    {
+        return new TranslatableText(this.getName());
+    }
+
+    /**
+     * Returns whether the action is activated or not.
+     *
+     * @return True if the action is activated, else false.
+     */
+    public boolean isActivated()
+    {
+        return this.activated;
+    }
+
+    public void activate(@NotNull RingButtonMode mode)
+    {
+        this.activated = !this.activated;
+
+        this.onAction(mode);
+    }
+
+    public abstract void onAction(@NotNull RingButtonMode mode);
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/ring/RingButtonMode.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.ring;
+
+import net.minecraft.text.Text;
+import net.minecraft.text.TranslatableText;
+import org.aperlambda.lambdacommon.utils.Nameable;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Represents the mode of a ring button.
+ *
+ * @author LambdAurora
+ * @version 1.4.0
+ * @since 1.4.0
+ */
+public enum RingButtonMode implements Nameable
+{
+    PRESS("press"),
+    HOLD("hold"),
+    TOGGLE("toggle");
+
+    private final String name;
+    private final Text   text;
+
+    RingButtonMode(@NotNull String name)
+    {
+        this.name = name;
+        this.text = new TranslatableText(this.getTranslationKey());
+    }
+
+    /**
+     * Returns the next ring button mode available.
+     *
+     * @return The next ring button mode.
+     */
+    public @NotNull RingButtonMode next()
+    {
+        RingButtonMode[] v = values();
+        if (v.length == this.ordinal() + 1)
+            return v[0];
+        return v[this.ordinal() + 1];
+    }
+
+    /**
+     * Returns the translation key of this ring button mode.
+     *
+     * @return The translation key of this ring button mode.
+     */
+    public @NotNull String getTranslationKey()
+    {
+        return "lambdacontrols.ring.button_mode." + this.getName();
+    }
+
+    /**
+     * Gets the translated name of this ring button mode.
+     *
+     * @return The translated name of this ring button mode.
+     */
+    public @NotNull Text getTranslatedText()
+    {
+        return this.text;
+    }
+
+    @Override
+    public @NotNull String getName()
+    {
+        return this.name;
+    }
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/ring/RingPage.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.ring;
+
+/**
+ * Represents a ring page.
+ *
+ * @author LambdAurora
+ * @version 1.4.0
+ * @since 1.4.0
+ */
+public class RingPage
+{
+    private RingAction[] actions = new RingAction[8];
+
+
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/util/HandledScreenAccessor.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.util;
+
+import net.minecraft.screen.slot.Slot;
+import net.minecraft.screen.slot.SlotActionType;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Represents an accessor to AbstractContainerScreen.
+ */
+public interface HandledScreenAccessor
+{
+    /**
+     * Gets the left coordinate of the GUI.
+     *
+     * @return The left coordinate of the GUI.
+     */
+    int getX();
+
+    /**
+     * Gets the top coordinate of the GUI.
+     *
+     * @return The top coordinate of the GUI.
+     */
+    int getY();
+
+    /**
+     * Gets the slot at position.
+     *
+     * @param pos_x The X position to check.
+     * @param pos_y The Y position to check.
+     * @return The slot at the specified position.
+     */
+    Slot lambdacontrols_getSlotAt(double pos_x, double pos_y);
+
+    boolean lambdacontrols_isClickOutsideBounds(double mouseX, double mouseY, int x, int y, int button);
+
+    /**
+     * Handles a mouse click on the specified slot.
+     *
+     * @param slot       The slot instance.
+     * @param slotId     The slot id.
+     * @param clickData  The click data.
+     * @param actionType The action type.
+     */
+    void lambdacontrols_onMouseClick(@Nullable Slot slot, int slotId, int clickData, SlotActionType actionType);
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/util/KeyBindingAccessor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2019 LambdAurora <aurora42lambda@gmail.com>
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
  *
  * This file is part of LambdaControls.
  *
@@ -7,23 +7,18 @@
  * see the LICENSE file.
  */
 
-package me.lambdaurora.lambdacontrols.util;
-
-import net.minecraft.client.util.InputUtil;
-import org.jetbrains.annotations.NotNull;
+package me.lambdaurora.lambdacontrols.client.util;
 
 /**
  * Represents a Minecraft keybinding with extra access.
  */
 public interface KeyBindingAccessor
 {
-    @NotNull InputUtil.KeyCode get_key_code();
-
     boolean lambdacontrols_press();
 
     boolean lambdacontrols_unpress();
 
-    default boolean handle_press_state(boolean pressed)
+    default boolean lambdacontrols_handlePressState(boolean pressed)
     {
         if (pressed)
             return this.lambdacontrols_press();

fabric/src/main/java/me/lambdaurora/lambdacontrols/client/util/MouseAccessor.java

@@ -0,0 +1,18 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.client.util;
+
+/**
+ * Represents mouse's extra access.
+ */
+public interface MouseAccessor
+{
+    void lambdacontrols_onCursorPos(long window, double x, double y);
+}

fabric/src/main/java/me/lambdaurora/lambdacontrols/event/PlayerChangeControlsModeCallback.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.event;
+
+import me.lambdaurora.lambdacontrols.ControlsMode;
+import net.fabricmc.fabric.api.event.Event;
+import net.fabricmc.fabric.api.event.EventFactory;
+import net.minecraft.entity.player.PlayerEntity;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Represents an event callback which is fired when a player changes the controls mode.
+ *
+ * @author LambdAurora
+ * @version 1.1.0
+ * @since 1.1.0
+ */
+@FunctionalInterface
+public interface PlayerChangeControlsModeCallback
+{
+    Event<PlayerChangeControlsModeCallback> EVENT = EventFactory.createArrayBacked(PlayerChangeControlsModeCallback.class, listeners -> (player, controlsMode) -> {
+        for (PlayerChangeControlsModeCallback event : listeners) {
+            event.apply(player, controlsMode);
+        }
+    });
+
+    void apply(@NotNull PlayerEntity player, @NotNull ControlsMode controlsMode);
+}

fabric/src/main/resources/assets/lambdacontrols/lang/en_us.json

@@ -0,0 +1,130 @@
+{
+  "key.lambdacontrols.look_down": "Look down",
+  "key.lambdacontrols.look_left": "Look left",
+  "key.lambdacontrols.look_right": "Look right",
+  "key.lambdacontrols.look_up": "Look up",
+  "lambdacontrols.action.attack": "Attack",
+  "lambdacontrols.action.back": "Back",
+  "lambdacontrols.action.chat": "Open Chat",
+  "lambdacontrols.action.drop_item": "Drop Item",
+  "lambdacontrols.action.exit": "Exit",
+  "lambdacontrols.action.forward": "Forward",
+  "lambdacontrols.action.hit": "Hit",
+  "lambdacontrols.action.hotbar_left": "Hotbar left",
+  "lambdacontrols.action.hotbar_right": "Hotbar right",
+  "lambdacontrols.action.inventory": "Inventory",
+  "lambdacontrols.action.jump": "Jump",
+  "lambdacontrols.action.left": "Left",
+  "lambdacontrols.action.pause_game": "Pause Game",
+  "lambdacontrols.action.pick_block": "Pick Block",
+  "lambdacontrols.action.pickup": "Pickup",
+  "lambdacontrols.action.pickup_all": "Pickup all",
+  "lambdacontrols.action.place": "Place",
+  "lambdacontrols.action.player_list": "Player List",
+  "lambdacontrols.action.quick_move": "Quick move",
+  "lambdacontrols.action.right": "Right",
+  "lambdacontrols.action.screenshot": "Take Screenshot",
+  "lambdacontrols.action.sneak": "Sneak",
+  "lambdacontrols.action.sprint": "Sprint",
+  "lambdacontrols.action.swap_hands": "Swap Hands",
+  "lambdacontrols.action.toggle_perspective": "Toggle Perspective",
+  "lambdacontrols.action.toggle_smooth_camera": "Toggle Cinematic Camera",
+  "lambdacontrols.action.use": "Use",
+  "lambdacontrols.action.zoom": "Zoom",
+  "lambdacontrols.action.zoom.in": "Increase Zoom",
+  "lambdacontrols.action.zoom.out": "Decrease Zoom",
+  "lambdacontrols.action.zoom.reset": "Reset Zoom",
+  "lambdacontrols.button.a": "A",
+  "lambdacontrols.button.b": "B",
+  "lambdacontrols.button.x": "X",
+  "lambdacontrols.button.y": "Y",
+  "lambdacontrols.button.left_bumper": "Left bumper",
+  "lambdacontrols.button.right_bumper": "Right bumper",
+  "lambdacontrols.button.back": "Back",
+  "lambdacontrols.button.start": "Start",
+  "lambdacontrols.button.guide": "Guide",
+  "lambdacontrols.button.left_thumb": "Left thumb",
+  "lambdacontrols.button.right_thumb": "Right thumb",
+  "lambdacontrols.button.dpad_up": "DPAD up",
+  "lambdacontrols.button.dpad_right": "DPAD right",
+  "lambdacontrols.button.dpad_down": "DPAD down",
+  "lambdacontrols.button.dpad_left": "DPAD left",
+  "lambdacontrols.axis.left_x+": "Left X+",
+  "lambdacontrols.axis.left_y+": "Left Y+",
+  "lambdacontrols.axis.right_x+": "Right X+",
+  "lambdacontrols.axis.right_y+": "Right Y+",
+  "lambdacontrols.axis.left_trigger": "Left trigger",
+  "lambdacontrols.axis.right_trigger": "Right trigger",
+  "lambdacontrols.axis.left_x-": "Left X-",
+  "lambdacontrols.axis.left_y-": "Left Y-",
+  "lambdacontrols.axis.right_x-": "Right X-",
+  "lambdacontrols.axis.right_y-": "Right Y-",
+  "lambdacontrols.button.unknown": "Unknown (%d)",
+  "lambdacontrols.controller.connected": "Controller %d connected.",
+  "lambdacontrols.controller.disconnected": "Controller %d disconnected.",
+  "lambdacontrols.controller.mappings.1": "To configure the controller mappings, please use %sSDL2 Gamepad Tool%s",
+  "lambdacontrols.controller.mappings.3": "and put the mapping in `%s.minecraft/config/gamecontrollerdb.txt%s`.",
+  "lambdacontrols.controller.mappings.updated": "Updated mappings!",
+  "lambdacontrols.controller_type.default": "default",
+  "lambdacontrols.controller_type.dualshock": "DualShock",
+  "lambdacontrols.controller_type.switch": "Switch",
+  "lambdacontrols.controller_type.xbox": "Xbox",
+  "lambdacontrols.controller_type.steam": "Steam",
+  "lambdacontrols.controller_type.ouya": "OUYA",
+  "lambdacontrols.controls_mode.default": "Keyboard/Mouse",
+  "lambdacontrols.controls_mode.controller": "Controller",
+  "lambdacontrols.controls_mode.touchscreen": "Touchscreen",
+  "lambdacontrols.hud_side.left": "left",
+  "lambdacontrols.hud_side.right": "right",
+  "lambdacontrols.menu.auto_switch_mode": "Auto Switch Mode",
+  "lambdacontrols.menu.controller": "Controller",
+  "lambdacontrols.menu.controller2": "Second Controller",
+  "lambdacontrols.menu.controller_type": "Controller Type",
+  "lambdacontrols.menu.controls_mode": "Mode",
+  "lambdacontrols.menu.dead_zone": "Dead Zone",
+  "lambdacontrols.menu.fast_block_placing": "Fast Block Placing",
+  "lambdacontrols.menu.fly_drifting": "Fly Drifting",
+  "lambdacontrols.menu.fly_drifting_vertical": "Vertical Fly Drifting",
+  "lambdacontrols.menu.hud_enable": "Enable HUD",
+  "lambdacontrols.menu.hud_side": "HUD Side",
+  "lambdacontrols.menu.invert_right_x_axis": "Invert Right X",
+  "lambdacontrols.menu.invert_right_y_axis": "Invert Right Y",
+  "lambdacontrols.menu.keyboard_controls": "Keyboard Controls...",
+  "lambdacontrols.menu.mouse_speed": "Mouse Speed",
+  "lambdacontrols.menu.reacharound.horizontal": "Front Block Placing",
+  "lambdacontrols.menu.reacharound.vertical": "Vertical Reacharound",
+  "lambdacontrols.menu.reload_controller_mappings": "Reload Controller Mappings",
+  "lambdacontrols.menu.rotation_speed": "Rotation Speed",
+  "lambdacontrols.menu.title": "LambdaControls - Settings",
+  "lambdacontrols.menu.title.controller": "Controller Options",
+  "lambdacontrols.menu.title.controller_controls": "Controller Controls",
+  "lambdacontrols.menu.title.gameplay": "Gameplay Options",
+  "lambdacontrols.menu.title.general": "General Options",
+  "lambdacontrols.menu.title.hud": "HUD Options",
+  "lambdacontrols.menu.unfocused_input": "Unfocused Input",
+  "lambdacontrols.menu.virtual_mouse": "Virtual Mouse",
+  "lambdacontrols.menu.virtual_mouse.skin": "Virtual Mouse Skin",
+  "lambdacontrols.narrator.unbound": "Unbound %s",
+  "lambdacontrols.not_bound": "Not bound",
+  "lambdacontrols.tooltip.auto_switch_mode": "If the controls mode should be switched to Controller automatically if one is connected.",
+  "lambdacontrols.tooltip.controller2": "Second controller to use, which allows Joy-Cons support for example.",
+  "lambdacontrols.tooltip.controller_type": "The controller type to display the correct buttons.",
+  "lambdacontrols.tooltip.controls_mode": "The controls mode.",
+  "lambdacontrols.tooltip.dead_zone": "The dead zone for the controller's analogue sticks.",
+  "lambdacontrols.tooltip.fast_block_placing": "While flying in creative mode, enables fast block placing depending on your speed. §cOn some servers this might be considered as cheating.",
+  "lambdacontrols.tooltip.fly_drifting": "While flying, enables Vanilla drifting/inertia.",
+  "lambdacontrols.tooltip.fly_drifting_vertical": "While flying, enables Vanilla vertical drifting/intertia.",
+  "lambdacontrols.tooltip.hud_enable": "Toggles the on-screen controller button indicator.",
+  "lambdacontrols.tooltip.hud_side": "The position of the HUD.",
+  "lambdacontrols.tooltip.mouse_speed": "The controller's emulated mouse speed.",
+  "lambdacontrols.tooltip.reacharound.horizontal": "Enables front block placing, §cmight be considered cheating on some servers§r.",
+  "lambdacontrols.tooltip.reacharound.vertical": "Enables vertical reacharound, §cmight be considered cheating on some servers§r.",
+  "lambdacontrols.tooltip.reload_controller_mappings": "Reloads the controller mappings file.",
+  "lambdacontrols.tooltip.rotation_speed": "The camera rotation speed in controller mode.",
+  "lambdacontrols.tooltip.unfocused_input": "Allow controller input when the window is not focused.",
+  "lambdacontrols.tooltip.virtual_mouse": "Enable the virtual mouse which is handful in the case of a splitscreen.",
+  "lambdacontrols.virtual_mouse.skin.default_light": "Default Light",
+  "lambdacontrols.virtual_mouse.skin.default_dark": "Default Dark",
+  "lambdacontrols.virtual_mouse.skin.second_light": "Second Light",
+  "lambdacontrols.virtual_mouse.skin.second_dark": "Second Dark"
+}

fabric/src/main/resources/assets/lambdacontrols/lang/fr_ca.json

@@ -0,0 +1,126 @@
+{
+  "key.lambdacontrols.look_down": "Regarder en bas",
+  "key.lambdacontrols.look_left": "Regarder à gauche",
+  "key.lambdacontrols.look_right": "Regarder à droite",
+  "key.lambdacontrols.look_up": "Regarder en haut",
+  "lambdacontrols.action.attack": "Attaquer",
+  "lambdacontrols.action.back": "Reculer",
+  "lambdacontrols.action.chat": "Ouvrir le tchat",
+  "lambdacontrols.action.drop_item": "Jeter l'objet",
+  "lambdacontrols.action.exit": "Sortir",
+  "lambdacontrols.action.forward": "Avancer",
+  "lambdacontrols.action.hit": "Taper",
+  "lambdacontrols.action.hotbar_left": "Case à gauche de la barre d'action",
+  "lambdacontrols.action.hotbar_right": "Case à droite de la barre d'action",
+  "lambdacontrols.action.inventory": "Inventaire",
+  "lambdacontrols.action.jump": "Sauter",
+  "lambdacontrols.action.left": "Aller à gauche",
+  "lambdacontrols.action.pause_game": "Mettre en pause le jeu",
+  "lambdacontrols.action.pick_block": "Choisir le bloc",
+  "lambdacontrols.action.pickup": "Prendre",
+  "lambdacontrols.action.pickup_all": "Prendre tout",
+  "lambdacontrols.action.place": "Placer",
+  "lambdacontrols.action.player_list": "Afficher la liste des joueurs",
+  "lambdacontrols.action.quick_move": "Mouvement rapide",
+  "lambdacontrols.action.right": "Aller à droite",
+  "lambdacontrols.action.screenshot": "Prendre une capture d'écran",
+  "lambdacontrols.action.sneak": "S'accroupir",
+  "lambdacontrols.action.sprint": "Courir",
+  "lambdacontrols.action.swap_hands": "Échanger de mains",
+  "lambdacontrols.action.toggle_perspective": "Changer de point de vue",
+  "lambdacontrols.action.toggle_smooth_camera": "Basculer en mode cinématique",
+  "lambdacontrols.action.use": "Utiliser",
+  "lambdacontrols.action.zoom": "Zoom",
+  "lambdacontrols.button.a": "A",
+  "lambdacontrols.button.b": "B",
+  "lambdacontrols.button.x": "X",
+  "lambdacontrols.button.y": "Y",
+  "lambdacontrols.button.left_bumper": "Gâchette haute gauche",
+  "lambdacontrols.button.right_bumper": "Gâchette haute droite",
+  "lambdacontrols.button.back": "Retour",
+  "lambdacontrols.button.start": "Touche Menu",
+  "lambdacontrols.button.guide": "Guide",
+  "lambdacontrols.button.left_thumb": "Stick gauche",
+  "lambdacontrols.button.right_thumb": "Stick droit",
+  "lambdacontrols.button.dpad_up": "D-Pad haut",
+  "lambdacontrols.button.dpad_right": "D-Pad droit",
+  "lambdacontrols.button.dpad_down": "D-Pad bas",
+  "lambdacontrols.button.dpad_left": "D-Pad gauche",
+  "lambdacontrols.axis.left_x+": "X+ Gauche",
+  "lambdacontrols.axis.left_y+": "Y+ Gauche",
+  "lambdacontrols.axis.right_x+": "X+ Droit",
+  "lambdacontrols.axis.right_y+": "Y+ Droit",
+  "lambdacontrols.axis.left_trigger": "Gâchette gauche",
+  "lambdacontrols.axis.right_trigger": "Gâchette droite",
+  "lambdacontrols.axis.left_x-": "X- Gauche",
+  "lambdacontrols.axis.left_y-": "Y- Gauche",
+  "lambdacontrols.axis.right_x-": "X- Droit",
+  "lambdacontrols.axis.right_y-": "Y- Droit",
+  "lambdacontrols.button.unknown": "Inconnu (%d)",
+  "lambdacontrols.controller.connected": "Manette %d connecté.",
+  "lambdacontrols.controller.disconnected": "Manette %d déconnecté.",
+  "lambdacontrols.controller.mappings.1": "Pour configurer les correspondances de la manette, veuillez utiliser %sSDL2 Gamepad Tool%s",
+  "lambdacontrols.controller.mappings.3": "et mettez les correspondances dans le fichier `%s.minecraft/config/gamecontrollerdb.txt%s`.",
+  "lambdacontrols.controller.mappings.updated": "Configuration des manettes mise à jour!",
+  "lambdacontrols.controller_type.default": "default",
+  "lambdacontrols.controller_type.dualshock": "DualShock",
+  "lambdacontrols.controller_type.switch": "Switch",
+  "lambdacontrols.controller_type.xbox": "Xbox",
+  "lambdacontrols.controller_type.steam": "Steam",
+  "lambdacontrols.controller_type.ouya": "OUYA",
+  "lambdacontrols.controls_mode.default": "Clavier/Souris",
+  "lambdacontrols.controls_mode.controller": "Manette",
+  "lambdacontrols.controls_mode.touchscreen": "Tactile",
+  "lambdacontrols.hud_side.left": "gauche",
+  "lambdacontrols.hud_side.right": "droit",
+  "lambdacontrols.menu.auto_switch_mode": "Changement auto de mode",
+  "lambdacontrols.menu.controller": "Manette",
+  "lambdacontrols.menu.controller2": "Deuxième manette",
+  "lambdacontrols.menu.controller_type": "Type de manette",
+  "lambdacontrols.menu.controls_mode": "Mode",
+  "lambdacontrols.menu.dead_zone": "Zone morte",
+  "lambdacontrols.menu.fly_drifting": "Inertie de vol",
+  "lambdacontrols.menu.fly_drifting_vertical": "Inertie verticale de vol",
+  "lambdacontrols.menu.hud_enable": "Activer le HUD",
+  "lambdacontrols.menu.hud_side": "Côté du HUD",
+  "lambdacontrols.menu.invert_right_x_axis": "Inverser le stick droit (X)",
+  "lambdacontrols.menu.invert_right_y_axis": "Inverser le stick droit (Y)",
+  "lambdacontrols.menu.keyboard_controls": "Contrôles clavier...",
+  "lambdacontrols.menu.mouse_speed": "Vitesse de la souris",
+  "lambdacontrols.menu.reacharound.horizontal": "Placement avant de bloc",
+  "lambdacontrols.menu.reacharound.vertical": "Placement vertical",
+  "lambdacontrols.menu.reload_controller_mappings": "Recharge la configuration des manettes",
+  "lambdacontrols.menu.rotation_speed": "Vitesse de rotation",
+  "lambdacontrols.menu.title": "LambdaControls - Paramètres",
+  "lambdacontrols.menu.title.controller": "Options de manettes",
+  "lambdacontrols.menu.title.controller_controls": "Contrôles de la manette",
+  "lambdacontrols.menu.title.gameplay": "Options de Gameplay",
+  "lambdacontrols.menu.title.general": "Options générales",
+  "lambdacontrols.menu.title.hud": "Options du HUD",
+  "lambdacontrols.menu.unfocused_input": "Entrée en fond",
+  "lambdacontrols.menu.virtual_mouse": "Souris virtuelle",
+  "lambdacontrols.menu.virtual_mouse.skin": "Apparence souris virtuelle",
+  "lambdacontrols.narrator.unbound": "Délier %s",
+  "lambdacontrols.not_bound": "Non défini",
+  "lambdacontrols.tooltip.auto_switch_mode": "Détermine si le mode de contrôle doit automatiquement changer sur Manette si une manette est connectée et inversement.",
+  "lambdacontrols.tooltip.controller2": "Défini une deuxième manette, utile dans le cas d'utilisation de Joy-Cons.",
+  "lambdacontrols.tooltip.controller_type": "Le type de contrôle n'influe que sur les boutons affichés.",
+  "lambdacontrols.tooltip.controls_mode": "Change le mode de contrôle.",
+  "lambdacontrols.tooltip.dead_zone": "Zone morte des axes de la manette.",
+  "lambdacontrols.tooltip.fast_block_placing": "Active le placement rapide de blocs en vol.",
+  "lambdacontrols.tooltip.fly_drifting": "Pendant que le joueur vole, active le glissement Vanilla.",
+  "lambdacontrols.tooltip.fly_drifting_vertical": "Pendant que le joueur vole, active le glissement vertical Vanilla.",
+  "lambdacontrols.tooltip.hud_enable": "Détermine si l'indicateur des buttons de la manette doit être affiché ou non.",
+  "lambdacontrols.tooltip.hud_side": "Change la position du HUD.",
+  "lambdacontrols.tooltip.mouse_speed": "Change la vitesse de la souris émulée par la manette.",
+  "lambdacontrols.tooltip.reacharound.horizontal": "Active le placement avant de blocs, §cpeut être considérer comme de la triche sur certains serveurs§r.",
+  "lambdacontrols.tooltip.reacharound.vertical": "Active le placement vertical de blocs, c'est-à-dire de blocs en dessous du bloc sur lequel vous êtes placé, §cpeut être considérer comme de la triche sur certains serveurs§r.",
+  "lambdacontrols.tooltip.reload_controller_mappings": "Recharge le fichier de configuration des manettes.",
+  "lambdacontrols.tooltip.rotation_speed": "Change la vitesse de rotation de la caméra.",
+  "lambdacontrols.tooltip.unfocused_input": "Autorise les entrées manette quand la fenêtre n'est pas sélectionnée.",
+  "lambdacontrols.tooltip.virtual_mouse": "Active la souris virtuelle qui est pratique dans le cas d'un écran partagé.",
+  "lambdacontrols.virtual_mouse.skin.default_light": "défaut clair",
+  "lambdacontrols.virtual_mouse.skin.default_dark": "défaut foncé",
+  "lambdacontrols.virtual_mouse.skin.second_light": "second clair",
+  "lambdacontrols.virtual_mouse.skin.second_dark": "second foncé"
+}

fabric/src/main/resources/assets/lambdacontrols/lang/fr_fr.json

@@ -10,6 +10,8 @@
   "lambdacontrols.action.exit": "Sortir",
   "lambdacontrols.action.forward": "Avancer",
   "lambdacontrols.action.hit": "Taper",
+  "lambdacontrols.action.hotbar_left": "Case à gauche de la barre d'action",
+  "lambdacontrols.action.hotbar_right": "Case à droite de la barre d'action",
   "lambdacontrols.action.inventory": "Inventaire",
   "lambdacontrols.action.jump": "Sauter",
   "lambdacontrols.action.left": "Aller à gauche",
@@ -17,6 +19,7 @@
   "lambdacontrols.action.pick_block": "Choisir le bloc",
   "lambdacontrols.action.pickup": "Prendre",
   "lambdacontrols.action.pickup_all": "Prendre tout",
+  "lambdacontrols.action.place": "Placer",
   "lambdacontrols.action.player_list": "Afficher la liste des joueurs",
   "lambdacontrols.action.quick_move": "Mouvement rapide",
   "lambdacontrols.action.right": "Aller à droite",
@@ -27,6 +30,7 @@
   "lambdacontrols.action.toggle_perspective": "Changer de point de vue",
   "lambdacontrols.action.toggle_smooth_camera": "Basculer en mode cinématique",
   "lambdacontrols.action.use": "Utiliser",
+  "lambdacontrols.action.zoom": "Zoom",
   "lambdacontrols.button.a": "A",
   "lambdacontrols.button.b": "B",
   "lambdacontrols.button.x": "X",
@@ -36,8 +40,8 @@
   "lambdacontrols.button.back": "Retour",
   "lambdacontrols.button.start": "Touche Menu",
   "lambdacontrols.button.guide": "Guide",
-  "lambdacontrols.button.left_thumb": "Stick analogique gauche",
-  "lambdacontrols.button.right_thumb": "Stick analogique droit",
+  "lambdacontrols.button.left_thumb": "Stick gauche",
+  "lambdacontrols.button.right_thumb": "Stick droit",
   "lambdacontrols.button.dpad_up": "D-Pad haut",
   "lambdacontrols.button.dpad_right": "D-Pad droit",
   "lambdacontrols.button.dpad_down": "D-Pad bas",
@@ -56,7 +60,6 @@
   "lambdacontrols.controller.connected": "Manette %d connecté.",
   "lambdacontrols.controller.disconnected": "Manette %d déconnecté.",
   "lambdacontrols.controller.mappings.1": "Pour configurer les correspondances de la manette, veuillez utiliser %sSDL2 Gamepad Tool%s",
-  "lambdacontrols.controller.mappings.2": "(%s%s%s),",
   "lambdacontrols.controller.mappings.3": "et mettez les correspondances dans le fichier `%s.minecraft/config/gamecontrollerdb.txt%s`.",
   "lambdacontrols.controller.mappings.updated": "Configuration des manettes mise à jour!",
   "lambdacontrols.controller_type.default": "default",
@@ -72,16 +75,52 @@
   "lambdacontrols.hud_side.right": "droit",
   "lambdacontrols.menu.auto_switch_mode": "Changement auto de mode",
   "lambdacontrols.menu.controller": "Manette",
+  "lambdacontrols.menu.controller2": "Deuxième manette",
   "lambdacontrols.menu.controller_type": "Type de manette",
   "lambdacontrols.menu.controls_mode": "Mode",
   "lambdacontrols.menu.dead_zone": "Zone morte",
+  "lambdacontrols.menu.fly_drifting": "Inertie de vol",
+  "lambdacontrols.menu.fly_drifting_vertical": "Inertie verticale de vol",
   "lambdacontrols.menu.hud_enable": "Activer le HUD",
   "lambdacontrols.menu.hud_side": "Côté du HUD",
-  "lambdacontrols.menu.invert_right_x_axis": "Inverser le joystick droit (X)",
-  "lambdacontrols.menu.invert_right_y_axis": "Inverser le joystick droit (Y)",
+  "lambdacontrols.menu.invert_right_x_axis": "Inverser le stick droit (X)",
+  "lambdacontrols.menu.invert_right_y_axis": "Inverser le stick droit (Y)",
+  "lambdacontrols.menu.keyboard_controls": "Contrôles clavier...",
   "lambdacontrols.menu.mouse_speed": "Vitesse de la souris",
+  "lambdacontrols.menu.reacharound.horizontal": "Placement avant de bloc",
+  "lambdacontrols.menu.reacharound.vertical": "Placement vertical",
   "lambdacontrols.menu.reload_controller_mappings": "Recharge la configuration des manettes",
   "lambdacontrols.menu.rotation_speed": "Vitesse de rotation",
   "lambdacontrols.menu.title": "LambdaControls - Paramètres",
-  "lambdacontrols.menu.title.controller_controls": "Contrôles de la manette"
+  "lambdacontrols.menu.title.controller": "Options de manettes",
+  "lambdacontrols.menu.title.controller_controls": "Contrôles de la manette",
+  "lambdacontrols.menu.title.gameplay": "Options de Gameplay",
+  "lambdacontrols.menu.title.general": "Options générales",
+  "lambdacontrols.menu.title.hud": "Options du HUD",
+  "lambdacontrols.menu.unfocused_input": "Entrée en fond",
+  "lambdacontrols.menu.virtual_mouse": "Souris virtuelle",
+  "lambdacontrols.menu.virtual_mouse.skin": "Apparence souris virtuelle",
+  "lambdacontrols.narrator.unbound": "Délier %s",
+  "lambdacontrols.not_bound": "Non défini",
+  "lambdacontrols.tooltip.auto_switch_mode": "Détermine si le mode de contrôle doit automatiquement changer sur Manette si une manette est connectée et inversement.",
+  "lambdacontrols.tooltip.controller2": "Défini une deuxième manette, utile dans le cas d'utilisation de Joy-Cons.",
+  "lambdacontrols.tooltip.controller_type": "Le type de contrôle n'influe que sur les boutons affichés.",
+  "lambdacontrols.tooltip.controls_mode": "Change le mode de contrôle.",
+  "lambdacontrols.tooltip.dead_zone": "Zone morte des axes de la manette.",
+  "lambdacontrols.tooltip.fast_block_placing": "Active le placement rapide de blocs en vol.",
+  "lambdacontrols.tooltip.fly_drifting": "Pendant que le joueur vole, active le glissement Vanilla.",
+  "lambdacontrols.tooltip.fly_drifting_vertical": "Pendant que le joueur vole, active le glissement vertical Vanilla.",
+  "lambdacontrols.tooltip.hud_enable": "Détermine si l'indicateur des buttons de la manette doit être affiché ou non.",
+  "lambdacontrols.tooltip.hud_side": "Change la position du HUD.",
+  "lambdacontrols.tooltip.mouse_speed": "Change la vitesse de la souris émulée par la manette.",
+  "lambdacontrols.tooltip.reacharound.horizontal": "Active le placement avant de blocs, §cpeut être considérer comme de la triche sur certains serveurs§r.",
+  "lambdacontrols.tooltip.reacharound.vertical": "Active le placement vertical de blocs, c'est-à-dire de blocs en dessous du bloc sur lequel vous êtes placé, §cpeut être considérer comme de la triche sur certains serveurs§r.",
+  "lambdacontrols.tooltip.reload_controller_mappings": "Recharge le fichier de configuration des manettes.",
+  "lambdacontrols.tooltip.rotation_speed": "Change la vitesse de rotation de la caméra.",
+  "lambdacontrols.tooltip.unfocused_input": "Autorise les entrées manette quand la fenêtre n'est pas sélectionnée.",
+  "lambdacontrols.tooltip.virtual_mouse": "Active la souris virtuelle qui est pratique dans le cas d'un écran partagé.",
+  "lambdacontrols.virtual_mouse.skin.default_light": "défaut clair",
+  "lambdacontrols.virtual_mouse.skin.default_dark": "défaut foncé",
+  "lambdacontrols.virtual_mouse.skin.second_light": "second clair",
+  "lambdacontrols.virtual_mouse.skin.second_dark": "second foncé"
 }

fabric/src/main/resources/config.toml

@@ -0,0 +1,115 @@
+# LambdaControls configuration.
+
+# The controls mode. Available modes: default, controller, touchscreen
+controls = "default"
+# Auto switch mode.
+auto_switch_mode = false
+
+[hud]
+    # Enables the HUD.
+    enable = true
+    # Dertermines where the movements buttons are.
+    side = "left"
+
+# Gameplay settings
+[gameplay]
+    # Enables fast block placing like in Bedrock Edition.
+    fast_block_placing = true
+    # Fly behaviors
+    [gameplay.fly]
+        # Enables fly drifting.
+        drifting = false
+        # Enables vertical fly drifting.
+        vertical_drifting = true
+    [gameplay.reacharound]
+        # Enables front block placing like in Bedrock Edition.
+        horizontal = false
+        # Enables vertical reacharound.
+        vertical = false
+        # Enables front block placing outline.
+        outline = true
+        # The color in a hexadecimal format of the outline.
+        outline_color = "#ffffff66"
+
+# Controller settings
+[controller]
+    # Controller to use.
+    id = 0
+    # Second controller to use.
+    id2 = -1
+    # Controller's type.
+    type = "default"
+    # Controller's dead zone.
+    dead_zone = 0.20
+    # Rotation speed for look directions.
+    rotation_speed = 10.0
+    # Mouse speed in GUI.
+    mouse_speed = 30.0
+    # Inverts the right X axis.
+    invert_right_x_axis = false
+    # Inverts the right Y axis.
+    invert_right_y_axis = false
+    # Allow unfocused input.
+    unfocused_input = false
+    # Virtual mouse.
+    virtual_mouse = false
+    # Virtual mouse skin
+    virtual_mouse_skin = "default_light"
+    # Controller controls.
+    [controller.controls]
+        # Attack control.
+        attack = "105"
+        # Back control.
+        back = "201"
+        # Open chat control.
+        chat = "12"
+        # Drop item control.
+        drop_item = "1"
+        # Forward control.
+        forward = "101"
+        # Hot-bar left control.
+        hotbar_left = "4"
+        # Hot-bar right control.
+        hotbar_right = "5"
+        # Inventory control.
+        inventory = "3"
+        # Jump control.
+        jump = "0"
+        # Left movement control.
+        left = "200"
+        # Pause game control.
+        pause_game = "7"
+        # Pick block control.
+        pick_block = "14"
+        # Show player list control.
+        player_list = "6"
+        # Right movement control.
+        right = "100"
+        # Take screenshot control.
+        screenshot = "11+0"
+        # Down slot control.
+        slot_down = "13"
+        # Left slot control.
+        slot_left = "14"
+        # Right slot control.
+        slot_right = "12"
+        # Up slot control.
+        slot_up = "11"
+        # Sneak control.
+        sneak = "10"
+        # Sprint control.
+        sprint = "9"
+        # Swap hands control.
+        swap_hands = "2"
+        # Switch to back tab control.
+        tab_back = "4"
+        # Switch to next tab control.
+        tab_next = "5"
+        # Toggle perspective control.
+        toggle_perspective = "11+3"
+        # Toggle smooth camera control.
+        toggle_smooth_camera = "-1"
+        # Use control.
+        use = "104"
+        # Zoom control.
+        zoom = "11+2"

fabric/src/main/resources/fabric.mod.json

@@ -16,22 +16,43 @@
   "icon": "assets/lambdacontrols/icon.png",
   "environment": "client",
   "entrypoints": {
-    "client": [
+    "main": [
       "me.lambdaurora.lambdacontrols.LambdaControls"
+    ],
+    "client": [
+      "me.lambdaurora.lambdacontrols.client.LambdaControlsClient"
+    ],
+    "modmenu": [
+      "me.lambdaurora.lambdacontrols.client.LambdaControlsModMenu"
     ]
   },
   "mixins": [
-    "lambdacontrols.mixins.json"
+    "lambdacontrols.mixins.json",
+    "lambdacontrols_compat.mixins.json"
   ],
   "depends": {
-    "fabricloader": ">=0.4.0",
+    "fabricloader": ">=0.8.0",
     "fabric": "*",
-    "minecraft": "1.15.x"
+    "minecraft": ">=1.16",
+    "spruceui": ">=1.5.2"
+  },
+  "recommends": {
+    "modmenu": ">=1.12.2"
   },
   "suggests": {
-    "flamingo": "*"
+    "flamingo": "*",
+    "roughlyenoughitems": ">=4.5.5",
+    "okzoomer": ">=4.0.0"
+  },
+  "breaks": {
+    "modmenu": "<1.12.2",
+    "optifabric": "*"
   },
   "custom": {
-    "modmenu:clientsideOnly": true
+    "modmenu:clientsideOnly": true,
+    "modupdater": {
+      "strategy": "curseforge",
+      "projectID": 354231
+    }
   }
 }

fabric/src/main/resources/lambdacontrols.mixins.json

@@ -0,0 +1,26 @@
+{
+  "required": true,
+  "package": "me.lambdaurora.lambdacontrols.client.mixin",
+  "compatibilityLevel": "JAVA_8",
+  "client": [
+    "AbstractButtonWidgetAccessor",
+    "AdvancementsScreenAccessor",
+    "ClientPlayerEntityMixin",
+    "ClientPlayNetworkHandlerMixin",
+    "ControlsOptionsScreenMixin",
+    "CreativeInventoryScreenAccessor",
+    "EntryListWidgetAccessor",
+    "GameOptionsMixin",
+    "GameRendererMixin",
+    "HandledScreenMixin",
+    "KeyBindingMixin",
+    "MinecraftClientMixin",
+    "MouseMixin",
+    "OptionsScreenMixin",
+    "RecipeBookWidgetAccessor",
+    "WorldRendererMixin"
+  ],
+  "injectors": {
+    "defaultRequire": 1
+  }
+}

fabric/src/main/resources/lambdacontrols_compat.mixins.json

@@ -0,0 +1,13 @@
+{
+  "required": true,
+  "package": "me.lambdaurora.lambdacontrols.client.compat.mixin",
+  "plugin": "me.lambdaurora.lambdacontrols.client.compat.LambdaControlsMixinPlugin",
+  "compatibilityLevel": "JAVA_8",
+  "client": [
+    "RecipeViewingScreenAccessor",
+    "VillagerRecipeViewingScreenAccessor"
+  ],
+  "injectors": {
+    "defaultRequire": 1
+  }
+}

gradle.properties

@@ -3,16 +3,17 @@ org.gradle.jvmargs=-Xmx1G
 
 # Fabric Properties
 	# check these on https://fabricmc.net/use
-	minecraft_version=1.15.1
-	yarn_mappings=1.15.1+build.3:v2
-	loader_version=0.7.2+build.174
+	minecraft_version=1.16.1
+	yarn_mappings=1.16.1+build.21:v2
+	loader_version=0.9.0+build.204
 
 # Mod Properties
-	mod_version = 1.0.1
-	maven_group = me.lambdaurora
+	mod_version = 1.4.1
+	maven_group = me.lambdaurora.lambdacontrols
 	archives_base_name = lambdacontrols
 
 # Dependencies
 	# currently not on the main fabric site, check on the maven: https://maven.fabricmc.net/net/fabricmc/fabric-api/fabric-api
-	fabric_version=0.4.25+build.282-1.15
-
+	fabric_version=0.15.0+build.379-1.16.1
+	spruceui_version=1.5.9
+	modmenu_version=1.12.2+build.17

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,5 @@
-#Mon Oct 28 18:23:18 CET 2019
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.5-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.5.1-all.zip

gradlew

@@ -82,6 +82,7 @@ esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
@@ -125,10 +126,11 @@ if $darwin; then
     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
 fi
 
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    
     JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
@@ -154,19 +156,19 @@ if $cygwin ; then
         else
             eval `echo args$i`="\"$arg\""
         fi
-        i=$((i+1))
+        i=`expr $i + 1`
     done
     case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+        0) set -- ;;
+        1) set -- "$args0" ;;
+        2) set -- "$args0" "$args1" ;;
+        3) set -- "$args0" "$args1" "$args2" ;;
+        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
     esac
 fi
 
@@ -175,14 +177,9 @@ save () {
     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
     echo " "
 }
-APP_ARGS=$(save "$@")
+APP_ARGS=`save "$@"`
 
 # Collect all arguments for the java command, following the shell quoting and substitution rules
 eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
 
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
-fi
-
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -1,100 +1,104 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

settings.gradle

@@ -8,3 +8,6 @@ pluginManagement {
         gradlePluginPortal()
     }
 }
+
+rootProject.name = 'lambdacontrols'
+include 'core', 'fabric', 'spigot'

spigot/build.gradle

@@ -0,0 +1,50 @@
+plugins {
+    id 'java-library'
+}
+
+archivesBaseName = project.archives_base_name + "-spigot"
+
+repositories {
+    maven { url = 'https://hub.spigotmc.org/nexus/content/groups/public/' }
+    maven { url = 'https://libraries.minecraft.net/' }
+}
+
+configurations {
+    include
+}
+
+dependencies {
+    api project(":core")
+    include(project(":core")) {
+        exclude group: 'com.google.code.gson'
+        exclude group: 'com.google.guava'
+    }
+    api 'org.spigotmc:spigot-api:1.15.1-R0.1-SNAPSHOT'
+    api 'io.netty:netty-all:4.1.28.Final'
+}
+
+processResources {
+    inputs.property "version", project.version
+
+    from(sourceSets.main.resources.srcDirs) {
+        include "plugin.yml"
+
+        expand 'version': project.version.toString().replace("#", "")
+    }
+}
+
+jar {
+    from '../LICENSE'
+
+    dependsOn configurations.include
+    from {
+        (configurations.include).collect {
+            it.isDirectory() ? it : zipTree(it)
+        }
+    }
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}

spigot/src/main/java/me/lambdaurora/lambdacontrols/LambdaControlsConfig.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols;
+
+import com.electronwill.nightconfig.core.file.FileConfig;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+
+/**
+ * Represents the LambdaControls Spigot configuration.
+ */
+public class LambdaControlsConfig
+{
+    private static final boolean DEFAULT_FRONT_BLOCK_PLACING = true;
+
+    protected final FileConfig           config = FileConfig.builder("config/lambdacontrols.toml").concurrent().defaultResource("/server_config.toml").build();
+    private final   LambdaControlsSpigot plugin;
+
+    public LambdaControlsConfig(@NotNull LambdaControlsSpigot plugin)
+    {
+        this.plugin = plugin;
+    }
+
+    public void load()
+    {
+        File configDir = new File("config/");
+        if (!configDir.exists())
+            configDir.mkdirs();
+        this.config.load();
+        this.plugin.log("Configuration loaded.");
+        LambdaControlsFeature.FRONT_BLOCK_PLACING.setAllowed(this.config.getOrElse("gameplay.front_block_placing", DEFAULT_FRONT_BLOCK_PLACING));
+    }
+}

spigot/src/main/java/me/lambdaurora/lambdacontrols/LambdaControlsSpigot.java

@@ -0,0 +1,148 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols;
+
+import io.netty.buffer.Unpooled;
+import me.lambdaurora.lambdacontrols.event.PlayerChangeControlsModeEvent;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.plugin.messaging.PluginMessageListener;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import static me.lambdaurora.lambdacontrols.LambdaControlsConstants.*;
+
+/**
+ * Represents the LambdaControls spigot plugin which provides extra features for servers.
+ *
+ * @author LambdAurora
+ * @version 1.1.0
+ * @since 1.1.0
+ */
+public class LambdaControlsSpigot extends JavaPlugin implements PluginMessageListener, Listener
+{
+    private static final Map<Player, ControlsMode> PLAYERS_CONTROLS_MODE = new HashMap<>();
+    public final         LambdaControlsConfig      config                = new LambdaControlsConfig(this);
+
+    @Override
+    public void onEnable()
+    {
+        super.onEnable();
+
+        this.config.load();
+
+        // Note that Spigot has a bullshit channel size restriction as Minecraft SUPPORTS UP TO 32767 AS CHANNEL SIZE.
+        // Please stop using that bad server software, move over Sponge or idk other things. REALLY.
+        this.getServer().getMessenger().registerIncomingPluginChannel(this, CONTROLS_MODE_CHANNEL.toString(), this);
+        this.getServer().getMessenger().registerOutgoingPluginChannel(this, CONTROLS_MODE_CHANNEL.toString());
+        this.getServer().getMessenger().registerOutgoingPluginChannel(this, FEATURE_CHANNEL.toString());
+        this.getServer().getMessenger().registerIncomingPluginChannel(this, HELLO_CHANNEL.toString(), this);
+        this.getServer().getPluginManager().registerEvents(this, this);
+
+        this.getServer().getOnlinePlayers().forEach(player -> {
+            PLAYERS_CONTROLS_MODE.put(player, ControlsMode.DEFAULT);
+
+            this.requestPlayerControlsMode(player);
+            this.updatePlayerFeature(player, LambdaControlsFeature.FRONT_BLOCK_PLACING);
+        });
+    }
+
+    @Override
+    public void onDisable()
+    {
+        super.onDisable();
+
+        this.getServer().getMessenger().unregisterIncomingPluginChannel(this, CONTROLS_MODE_CHANNEL.toString());
+        this.getServer().getMessenger().unregisterOutgoingPluginChannel(this, CONTROLS_MODE_CHANNEL.toString());
+        this.getServer().getMessenger().unregisterOutgoingPluginChannel(this, FEATURE_CHANNEL.toString());
+        this.getServer().getMessenger().unregisterIncomingPluginChannel(this, HELLO_CHANNEL.toString());
+
+        PLAYERS_CONTROLS_MODE.clear();
+    }
+
+    public void requestPlayerControlsMode(@NotNull Player player)
+    {
+        player.sendPluginMessage(this, CONTROLS_MODE_CHANNEL.toString(), new byte[0]);
+    }
+
+    public void updatePlayerFeature(@NotNull Player player, @NotNull LambdaControlsFeature feature)
+    {
+        Objects.requireNonNull(player);
+        Objects.requireNonNull(feature);
+
+        player.sendPluginMessage(this, FEATURE_CHANNEL.toString(), this.makeFeatureMessage(feature));
+    }
+
+    /**
+     * Prints a message to the terminal.
+     *
+     * @param info The message to print.
+     */
+    public void log(String info)
+    {
+        this.getLogger().info(info);
+    }
+
+    @Override
+    public void onPluginMessageReceived(@NotNull String channel, @NotNull Player player, @NotNull byte[] message)
+    {
+        if (channel.equals(HELLO_CHANNEL.toString())) {
+            NettyPacketBuffer buffer = new NettyPacketBuffer(Unpooled.copiedBuffer(message));
+            String version = buffer.readString(16);
+            ControlsMode.byId(buffer.readString(32)).ifPresent(controlsMode -> {
+                PLAYERS_CONTROLS_MODE.put(player, controlsMode);
+                PlayerChangeControlsModeEvent event = new PlayerChangeControlsModeEvent(player, controlsMode);
+                this.getServer().getPluginManager().callEvent(event);
+            });
+            this.updatePlayerFeature(player, LambdaControlsFeature.FRONT_BLOCK_PLACING);
+        } else if (channel.equals(CONTROLS_MODE_CHANNEL.toString())) {
+            NettyPacketBuffer buffer = new NettyPacketBuffer(Unpooled.copiedBuffer(message));
+            ControlsMode.byId(buffer.readString(32)).ifPresent(controlsMode -> {
+                PLAYERS_CONTROLS_MODE.put(player, controlsMode);
+                PlayerChangeControlsModeEvent event = new PlayerChangeControlsModeEvent(player, controlsMode);
+                this.getServer().getPluginManager().callEvent(event);
+            });
+        }
+    }
+
+    /**
+     * Returns a packet byte buffer made for the lambdacontrols:feature plugin message.
+     *
+     * @param feature The feature data to send.
+     * @return The packet byte buffer.
+     */
+    public byte[] makeFeatureMessage(@NotNull LambdaControlsFeature feature)
+    {
+        Objects.requireNonNull(feature, "Feature cannot be null.");
+        NettyPacketBuffer buffer = new NettyPacketBuffer(Unpooled.buffer());
+        buffer.writeString(feature.getName());
+        buffer.writeBoolean(feature.isAllowed());
+        return buffer.array();
+    }
+
+    @EventHandler
+    public void onPlayerJoin(@NotNull PlayerJoinEvent event)
+    {
+        PLAYERS_CONTROLS_MODE.put(event.getPlayer(), ControlsMode.DEFAULT);
+    }
+
+    @EventHandler
+    public void onPlayerLeave(@NotNull PlayerQuitEvent event)
+    {
+        PLAYERS_CONTROLS_MODE.remove(event.getPlayer());
+    }
+}

spigot/src/main/java/me/lambdaurora/lambdacontrols/NettyPacketBuffer.java

@@ -0,0 +1,102 @@
+package me.lambdaurora.lambdacontrols;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.handler.codec.DecoderException;
+import io.netty.handler.codec.EncoderException;
+
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+
+public class NettyPacketBuffer extends PacketBuffer
+{
+    public NettyPacketBuffer(ByteBuf byteBuf)
+    {
+        super(byteBuf);
+    }
+
+    @Override
+    public int readVarint()
+    {
+        int var1 = 0;
+        int var2 = 0;
+        byte var3;
+
+        do {
+            var3 = this.readByte();
+            var1 |= (var3 & 127) << var2++ * 7;
+
+            if (var2 > 5)
+                throw new RuntimeException("VarInt too big");
+        } while ((var3 & 128) == 128);
+
+        return var1;
+    }
+
+    @Override
+    public void writeVarint(int input)
+    {
+        while ((input & -128) != 0) {
+            this.writeByte(input & 127 | 128);
+            input >>>= 7;
+        }
+
+        this.writeByte(input);
+    }
+
+    @Override
+    public String readString(int maxLength)
+    {
+        int var2 = this.readVarint();
+
+        if (var2 > maxLength * 4)
+            throw new DecoderException("The received encoded string buffer length is longer than maximum allowed (" + var2 + " > " + maxLength * 4 + ")");
+        else if (var2 < 0)
+            throw new DecoderException("The received encoded string buffer length is less than zero! Weird string!");
+        else {
+            String var3 = this.readCharSequence(var2, StandardCharsets.UTF_8).toString();
+
+            if (var3.length() > maxLength)
+                throw new DecoderException("The received string length is longer than maximum allowed (" + var2 + " > " + maxLength + ")");
+            else
+                return var3;
+        }
+    }
+
+    @Override
+    public void writeString(String string)
+    {
+        byte[] var2 = string.getBytes(Charset.forName("UTF-8"));
+
+        if (var2.length > 32767) {
+            throw new EncoderException("String too big (was " + string.length() + " data encoded, max " + 32767 + ")");
+        } else {
+            this.writeVarint(var2.length);
+            this.writeCharSequence(string, StandardCharsets.UTF_8);
+        }
+    }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+
+        NettyPacketBuffer buffer = (NettyPacketBuffer) o;
+
+        return byteBuf.equals(buffer.byteBuf);
+    }
+
+    @Override
+    public int compareTo(ByteBuf buffer)
+    {
+        return this.byteBuf.compareTo(buffer);
+    }
+
+    @Override
+    public String toString()
+    {
+        return this.byteBuf.toString();
+    }
+}

spigot/src/main/java/me/lambdaurora/lambdacontrols/event/PlayerChangeControlsModeEvent.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright © 2020 LambdAurora <aurora42lambda@gmail.com>
+ *
+ * This file is part of LambdaControls.
+ *
+ * Licensed under the MIT license. For more information,
+ * see the LICENSE file.
+ */
+
+package me.lambdaurora.lambdacontrols.event;
+
+import me.lambdaurora.lambdacontrols.ControlsMode;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.player.PlayerEvent;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Represents an event which is fired when a player change their controls mode.
+ *
+ * @author LambdAurora
+ * @version 1.1.0
+ * @since 1.1.0
+ */
+public class PlayerChangeControlsModeEvent extends PlayerEvent
+{
+    private static final HandlerList  HANDLERS = new HandlerList();
+    private final        ControlsMode controlsMode;
+
+    public PlayerChangeControlsModeEvent(@NotNull Player who, @NotNull ControlsMode controlsMode)
+    {
+        super(who);
+        this.controlsMode = controlsMode;
+    }
+
+    /**
+     * Returns the controls mode of the player.
+     *
+     * @return The player's controls mode.
+     */
+    public ControlsMode getControlsMode()
+    {
+        return this.controlsMode;
+    }
+
+    @Override
+    public String toString()
+    {
+        return "PlayerChangeControlsModeEvent{" +
+                "player=" + this.player +
+                ", controls_mode=" + this.controlsMode +
+                '}';
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers()
+    {
+        return HANDLERS;
+    }
+
+    public static @NotNull HandlerList getHandlerList()
+    {
+        return HANDLERS;
+    }
+}

spigot/src/main/resources/plugin.yml

@@ -0,0 +1,6 @@
+name: LambdaControls
+version: ${version}
+description: A quick Spigot plugin for LambdaControls which allow server admins to disable some features.
+
+main: me.lambdaurora.lambdacontrols.LambdaControlsSpigot
+api-version: 1.13

spigot/src/main/resources/server_config.toml

@@ -0,0 +1,6 @@
+# LambdaControls server configuration.
+
+# Gameplay settings
+[gameplay]
+    # Allows front block placing like in Bedrock Edition.
+    front_block_placing = true

src/main/java/me/lambdaurora/lambdacontrols/ButtonBinding.java

@@ -1,507 +0,0 @@
-/*
- * Copyright © 2019 LambdAurora <aurora42lambda@gmail.com>
- *
- * This file is part of LambdaControls.
- *
- * Licensed under the MIT license. For more information,
- * see the LICENSE file.
- */
-
-package me.lambdaurora.lambdacontrols;
-
-import me.lambdaurora.lambdacontrols.util.KeyBindingAccessor;
-import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.options.GameOptions;
-import net.minecraft.client.options.KeyBinding;
-import net.minecraft.client.resource.language.I18n;
-import net.minecraft.client.util.ScreenshotUtils;
-import org.aperlambda.lambdacommon.Identifier;
-import org.aperlambda.lambdacommon.utils.Identifiable;
-import org.aperlambda.lambdacommon.utils.Nameable;
-import org.jetbrains.annotations.NotNull;
-import org.lwjgl.glfw.GLFW;
-
-import java.util.*;
-import java.util.function.Consumer;
-import java.util.stream.Stream;
-
-/**
- * Represents a button binding.
- *
- * @author LambdAurora
- */
-public class ButtonBinding implements Nameable
-{
-    private static final List<ButtonBinding> BINDINGS           = new ArrayList<>();
-    private static final List<Category>      CATEGORIES         = new ArrayList<>();
-    public static final  Category            MOVEMENT_CATEGORY;
-    public static final  Category            GAMEPLAY_CATEGORY;
-    public static final  Category            INVENTORY_CATEGORY;
-    public static final  Category            MULTIPLAYER_CATEGORY;
-    public static final  Category            MISC_CATEGORY;
-    public static final  ButtonBinding       ATTACK             = new ButtonBinding("attack", axis_as_button(GLFW.GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER, true));
-    public static final  ButtonBinding       BACK               = new ButtonBinding("back", axis_as_button(GLFW.GLFW_GAMEPAD_AXIS_LEFT_Y, false));
-    public static final  ButtonBinding       CHAT               = new ButtonBinding("chat", GLFW.GLFW_GAMEPAD_BUTTON_DPAD_RIGHT);
-    public static final  ButtonBinding       DROP_ITEM          = new ButtonBinding("drop_item", GLFW.GLFW_GAMEPAD_BUTTON_B);
-    public static final  ButtonBinding       FORWARD            = new ButtonBinding("forward", axis_as_button(GLFW.GLFW_GAMEPAD_AXIS_LEFT_Y, true));
-    public static final  ButtonBinding       INVENTORY          = new ButtonBinding("inventory", GLFW.GLFW_GAMEPAD_BUTTON_Y);
-    public static final  ButtonBinding       JUMP               = new ButtonBinding("jump", GLFW.GLFW_GAMEPAD_BUTTON_A);
-    public static final  ButtonBinding       LEFT               = new ButtonBinding("left", axis_as_button(GLFW.GLFW_GAMEPAD_AXIS_LEFT_X, false));
-    public static final  ButtonBinding       PAUSE_GAME         = new ButtonBinding("pause_game", GLFW.GLFW_GAMEPAD_BUTTON_START);
-    public static final  ButtonBinding       PICK_BLOCK         = new ButtonBinding("pick_block", GLFW.GLFW_GAMEPAD_BUTTON_DPAD_LEFT);
-    public static final  ButtonBinding       PLAYER_LIST        = new ButtonBinding("player_list", GLFW.GLFW_GAMEPAD_BUTTON_BACK);
-    public static final  ButtonBinding       RIGHT              = new ButtonBinding("right", axis_as_button(GLFW.GLFW_GAMEPAD_AXIS_LEFT_X, true));
-    public static final  ButtonBinding       SCREENSHOT         = new ButtonBinding("screenshot", GLFW.GLFW_GAMEPAD_BUTTON_DPAD_DOWN,
-            Collections.singletonList((client, action) -> {
-                if (action == 0)
-                    ScreenshotUtils.saveScreenshot(client.runDirectory, client.getWindow().getFramebufferWidth(), client.getWindow().getFramebufferHeight(), client.getFramebuffer(),
-                            text -> client.execute(() -> client.inGameHud.getChatHud().addMessage(text)));
-                return true;
-            }));
-    public static final  ButtonBinding       SMOOTH_CAMERA      = new ButtonBinding("toggle_smooth_camera", -1);
-    public static final  ButtonBinding       SNEAK              = new ButtonBinding("sneak", GLFW.GLFW_GAMEPAD_BUTTON_RIGHT_THUMB);
-    public static final  ButtonBinding       SPRINT             = new ButtonBinding("sprint", GLFW.GLFW_GAMEPAD_BUTTON_LEFT_THUMB);
-    public static final  ButtonBinding       SWAP_HANDS         = new ButtonBinding("swap_hands", GLFW.GLFW_GAMEPAD_BUTTON_X);
-    public static final  ButtonBinding       TOGGLE_PERSPECTIVE = new ButtonBinding("toggle_perspective", GLFW.GLFW_GAMEPAD_BUTTON_DPAD_UP);
-    public static final  ButtonBinding       USE                = new ButtonBinding("use", axis_as_button(GLFW.GLFW_GAMEPAD_AXIS_LEFT_TRIGGER, true));
-
-    private int               button;
-    private int               default_button;
-    private String            key;
-    private KeyBinding        minecraft_key_binding = null;
-    private List<PressAction> actions               = new ArrayList<>(Collections.singletonList((client, action) -> {
-        this.as_key_binding().ifPresent(key_binding -> ((KeyBindingAccessor) key_binding).handle_press_state(this.is_button_down()));
-        return true;
-    }));
-    private boolean           pressed               = false;
-
-    protected ButtonBinding(@NotNull String key, int default_button, @NotNull List<PressAction> actions)
-    {
-        this.default_button = this.button = default_button;
-        this.key = key;
-        this.actions.addAll(actions);
-        BINDINGS.add(this);
-    }
-
-    protected ButtonBinding(@NotNull String key, int default_button)
-    {
-        this(key, default_button, Collections.emptyList());
-    }
-
-    /**
-     * Returns the button bound.
-     *
-     * @return The bound button.
-     */
-    public int get_button()
-    {
-        return this.button;
-    }
-
-    /**
-     * Sets the bound button.
-     *
-     * @param button The bound button.
-     */
-    public void set_button(int button)
-    {
-        this.button = button;
-    }
-
-    /**
-     * 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 is_button(int button)
-    {
-        return this.button == button;
-    }
-
-    /**
-     * Returns whether this button is down or not.
-     *
-     * @return True if the button is down, else false.
-     */
-    public boolean is_button_down()
-    {
-        return this.pressed;
-    }
-
-    /**
-     * Returns whether this button binding is bound or not.
-     *
-     * @return True if this button binding is bound, else false.
-     */
-    public boolean is_not_bound()
-    {
-        return this.button == -1;
-    }
-
-    /**
-     * Gets the default button assigned to this binding.
-     *
-     * @return The default button.
-     */
-    public int get_default_button()
-    {
-        return this.default_button;
-    }
-
-    /**
-     * Returns whether the assigned button is the default button.
-     *
-     * @return True if the assigned button is the default button, else false.
-     */
-    public boolean is_default()
-    {
-        return this.button == this.default_button;
-    }
-
-    @Override
-    public @NotNull String get_name()
-    {
-        return this.key;
-    }
-
-    /**
-     * Returns the translation key of this button binding.
-     *
-     * @return The translation key.
-     */
-    public @NotNull String get_translation_key()
-    {
-        return "lambdacontrols.action." + this.get_name();
-    }
-
-    /**
-     * Returns the key binding equivalent of this button binding.
-     *
-     * @return The key binding equivalent.
-     */
-    public @NotNull Optional<KeyBinding> as_key_binding()
-    {
-        return Optional.ofNullable(this.minecraft_key_binding);
-    }
-
-    /**
-     * 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 axis_as_button(int axis, boolean positive)
-    {
-        return positive ? 100 + axis : 200 + axis;
-    }
-
-    /**
-     * Returns the second Joycon's specified button code.
-     *
-     * @param button The raw button code.
-     * @return The second Joycon's button code.
-     */
-    public static int joycon2_button(int button)
-    {
-        return 300 + button;
-    }
-
-    public static void init(@NotNull GameOptions options)
-    {
-        ATTACK.minecraft_key_binding = options.keyAttack;
-        BACK.minecraft_key_binding = options.keyBack;
-        CHAT.minecraft_key_binding = options.keyChat;
-        DROP_ITEM.minecraft_key_binding = options.keyDrop;
-        FORWARD.minecraft_key_binding = options.keyForward;
-        INVENTORY.minecraft_key_binding = options.keyInventory;
-        JUMP.minecraft_key_binding = options.keyJump;
-        LEFT.minecraft_key_binding = options.keyLeft;
-        PICK_BLOCK.minecraft_key_binding = options.keyPickItem;
-        PLAYER_LIST.minecraft_key_binding = options.keyPlayerList;
-        RIGHT.minecraft_key_binding = options.keyRight;
-        SCREENSHOT.minecraft_key_binding = options.keyScreenshot;
-        SMOOTH_CAMERA.minecraft_key_binding = options.keySmoothCamera;
-        SNEAK.minecraft_key_binding = options.keySneak;
-        SPRINT.minecraft_key_binding = options.keySprint;
-        SWAP_HANDS.minecraft_key_binding = options.keySwapHands;
-        TOGGLE_PERSPECTIVE.minecraft_key_binding = options.keyTogglePerspective;
-        USE.minecraft_key_binding = options.keyUse;
-    }
-
-    public static void load_from_config(@NotNull LambdaControlsConfig config)
-    {
-        BINDINGS.forEach(config::load_button_binding);
-    }
-
-    public static void set_button_state(int button, boolean state)
-    {
-        BINDINGS.parallelStream().filter(binding -> Objects.equals(binding.button, button))
-                .forEach(binding -> binding.pressed = state);
-    }
-
-    public static void handle_button(@NotNull MinecraftClient client, int button, int action)
-    {
-        BINDINGS.parallelStream().filter(binding -> binding.button == button)
-                .forEach(binding -> {
-                    for (int i = binding.actions.size() - 1; i >= 0; i--) {
-                        if (binding.actions.get(i).press(client, action))
-                            break;
-                    }
-                });
-    }
-
-    /**
-     * 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 has_duplicates(int button)
-    {
-        return BINDINGS.parallelStream().filter(binding -> binding.button == button).count() > 1;
-    }
-
-    /**
-     * Returns the localized name of the specified button.
-     *
-     * @param button The button.
-     * @return The localized name of the button.
-     */
-    public static @NotNull String get_localized_button_name(int button)
-    {
-        switch (button) {
-            case -1:
-                return I18n.translate("key.keyboard.unknown");
-            case GLFW.GLFW_GAMEPAD_BUTTON_A:
-                return I18n.translate("lambdacontrols.button.a");
-            case GLFW.GLFW_GAMEPAD_BUTTON_B:
-                return I18n.translate("lambdacontrols.button.b");
-            case GLFW.GLFW_GAMEPAD_BUTTON_X:
-                return I18n.translate("lambdacontrols.button.x");
-            case GLFW.GLFW_GAMEPAD_BUTTON_Y:
-                return I18n.translate("lambdacontrols.button.y");
-            case GLFW.GLFW_GAMEPAD_BUTTON_LEFT_BUMPER:
-                return I18n.translate("lambdacontrols.button.left_bumper");
-            case GLFW.GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER:
-                return I18n.translate("lambdacontrols.button.right_bumper");
-            case GLFW.GLFW_GAMEPAD_BUTTON_BACK:
-                return I18n.translate("lambdacontrols.button.back");
-            case GLFW.GLFW_GAMEPAD_BUTTON_START:
-                return I18n.translate("lambdacontrols.button.start");
-            case GLFW.GLFW_GAMEPAD_BUTTON_GUIDE:
-                return I18n.translate("lambdacontrols.button.guide");
-            case GLFW.GLFW_GAMEPAD_BUTTON_LEFT_THUMB:
-                return I18n.translate("lambdacontrols.button.left_thumb");
-            case GLFW.GLFW_GAMEPAD_BUTTON_RIGHT_THUMB:
-                return I18n.translate("lambdacontrols.button.right_thumb");
-            case GLFW.GLFW_GAMEPAD_BUTTON_DPAD_UP:
-                return I18n.translate("lambdacontrols.button.dpad_up");
-            case GLFW.GLFW_GAMEPAD_BUTTON_DPAD_RIGHT:
-                return I18n.translate("lambdacontrols.button.dpad_right");
-            case GLFW.GLFW_GAMEPAD_BUTTON_DPAD_DOWN:
-                return I18n.translate("lambdacontrols.button.dpad_down");
-            case GLFW.GLFW_GAMEPAD_BUTTON_DPAD_LEFT:
-                return I18n.translate("lambdacontrols.button.dpad_left");
-            case 100:
-                return I18n.translate("lambdacontrols.axis.left_x+");
-            case 101:
-                return I18n.translate("lambdacontrols.axis.left_y+");
-            case 102:
-                return I18n.translate("lambdacontrols.axis.right_x+");
-            case 103:
-                return I18n.translate("lambdacontrols.axis.right_y+");
-            case 104:
-                return I18n.translate("lambdacontrols.axis.left_trigger");
-            case 105:
-                return I18n.translate("lambdacontrols.axis.right_trigger");
-            case 200:
-                return I18n.translate("lambdacontrols.axis.left_x-");
-            case 201:
-                return I18n.translate("lambdacontrols.axis.left_y-");
-            case 202:
-                return I18n.translate("lambdacontrols.axis.right_x-");
-            case 203:
-                return I18n.translate("lambdacontrols.axis.right_y-");
-            default:
-                return I18n.translate("lambdacontrols.button.unknown", button);
-        }
-    }
-
-    public static @NotNull Stream<ButtonBinding> stream()
-    {
-        return BINDINGS.stream();
-    }
-
-    public static @NotNull Stream<Category> stream_categories()
-    {
-        return CATEGORIES.stream();
-    }
-
-    static {
-        MOVEMENT_CATEGORY = register_default_category("key.categories.movement", category -> category.register_all_bindings(
-                FORWARD,
-                BACK,
-                LEFT,
-                RIGHT,
-                JUMP,
-                SNEAK,
-                SPRINT));
-        GAMEPLAY_CATEGORY = register_default_category("key.categories.gameplay", category -> category.register_all_bindings(
-                ATTACK,
-                PICK_BLOCK,
-                USE
-        ));
-        INVENTORY_CATEGORY = register_default_category("key.categories.inventory", category -> category.register_all_bindings(
-                DROP_ITEM,
-                INVENTORY,
-                SWAP_HANDS
-        ));
-        MULTIPLAYER_CATEGORY = register_default_category("key.categories.multiplayer",
-                category -> category.register_all_bindings(CHAT, PLAYER_LIST));
-        MISC_CATEGORY = register_default_category("key.categories.misc", category -> category.register_all_bindings(
-                SCREENSHOT,
-                //SMOOTH_CAMERA,
-                TOGGLE_PERSPECTIVE
-        ));
-    }
-
-    public static ButtonBinding register(@NotNull Identifier binding_id, int default_button, @NotNull List<PressAction> actions)
-    {
-        return new ButtonBinding(binding_id.get_namespace() + "." + binding_id.get_name(), default_button, actions);
-    }
-
-    public static ButtonBinding register(@NotNull Identifier binding_id, int default_button)
-    {
-        return register(binding_id, default_button, Collections.emptyList());
-    }
-
-    public static ButtonBinding register(@NotNull net.minecraft.util.Identifier binding_id, int default_button, @NotNull List<PressAction> actions)
-    {
-        return register(new Identifier(binding_id.getNamespace(), binding_id.getPath()), default_button, actions);
-    }
-
-    public static ButtonBinding register(@NotNull net.minecraft.util.Identifier binding_id, int default_button)
-    {
-        return register(binding_id, default_button, Collections.emptyList());
-    }
-
-    /**
-     * Registers a category of button bindings.
-     *
-     * @param category The category to register.
-     * @return The registered category.
-     */
-    public static Category register_category(@NotNull Category category)
-    {
-        CATEGORIES.add(category);
-        return category;
-    }
-
-    public static Category register_category(@NotNull Identifier identifier, int priority)
-    {
-        return register_category(new Category(identifier, priority));
-    }
-
-    public static Category register_category(@NotNull Identifier identifier)
-    {
-        return register_category(new Category(identifier));
-    }
-
-    private static Category register_default_category(@NotNull String key, @NotNull Consumer<Category> key_adder)
-    {
-        Category category = register_category(new Identifier("minecraft", key), CATEGORIES.size());
-        key_adder.accept(category);
-        return category;
-    }
-
-    public static class Category implements Identifiable
-    {
-        private final List<ButtonBinding> bindings = new ArrayList<>();
-        private final Identifier          id;
-        private       int                 priority;
-
-        public Category(@NotNull Identifier id, int priority)
-        {
-            this.id = id;
-            this.priority = priority;
-        }
-
-        public Category(@NotNull Identifier id)
-        {
-            this(id, 100);
-        }
-
-        public void register_binding(@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 register_all_bindings(@NotNull ButtonBinding... bindings)
-        {
-            this.register_all_bindings(Arrays.asList(bindings));
-        }
-
-        public void register_all_bindings(@NotNull List<ButtonBinding> bindings)
-        {
-            bindings.forEach(this::register_binding);
-        }
-
-        /**
-         * Gets the bindings assigned to this category.
-         *
-         * @return The bindings assigned to this category.
-         */
-        public @NotNull List<ButtonBinding> get_bindings()
-        {
-            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 get_translated_name()
-        {
-            if (this.id.get_namespace().equals("minecraft"))
-                return I18n.translate(this.id.get_name());
-            else
-                return I18n.translate(this.id.get_namespace() + "." + this.id.get_name());
-        }
-
-        /**
-         * 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 get_priority()
-        {
-            return this.priority;
-        }
-
-        @Override
-        public @NotNull Identifier get_identifier()
-        {
-            return this.id;
-        }
-    }
-
-    @FunctionalInterface
-    public static interface PressAction
-    {
-        /**
-         * Handles when there is a press action on the button.
-         *
-         * @param client The client instance.
-         * @param action The action done.
-         */
-        boolean press(@NotNull MinecraftClient client, int action);
-    }
-}

src/main/java/me/lambdaurora/lambdacontrols/HudSide.java

@@ -1,66 +0,0 @@
-/*
- * Copyright © 2019 LambdAurora <aurora42lambda@gmail.com>
- *
- * This file is part of LambdaControls.
- *
- * Licensed under the MIT license. For more information,
- * see the LICENSE file.
- */
-
-package me.lambdaurora.lambdacontrols;
-
-import net.minecraft.client.resource.language.I18n;
-import org.aperlambda.lambdacommon.utils.Nameable;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Arrays;
-import java.util.Optional;
-
-/**
- * Represents the hud side which is the side where the movements buttons are.
- */
-public enum HudSide implements Nameable
-{
-    LEFT,
-    RIGHT;
-
-    /**
-     * Returns the next side available.
-     *
-     * @return The next available side.
-     */
-    public HudSide next()
-    {
-        HudSide[] v = values();
-        if (v.length == this.ordinal() + 1)
-            return v[0];
-        return v[this.ordinal() + 1];
-    }
-
-    /**
-     * Gets the translated name of this hud side.
-     *
-     * @return The translated name of this hud side.
-     */
-    public String get_translated_name()
-    {
-        return I18n.translate("lambdacontrols.hud_side." + this.get_name());
-    }
-
-    @Override
-    public @NotNull String get_name()
-    {
-        return this.name().toLowerCase();
-    }
-
-    /**
-     * Gets the hud side from its identifier.
-     *
-     * @param id The identifier of the hud side.
-     * @return The hud side if found, else empty.
-     */
-    public static Optional<HudSide> by_id(@NotNull String id)
-    {
-        return Arrays.stream(values()).filter(mode -> mode.get_name().equalsIgnoreCase(id)).findFirst();
-    }
-}

src/main/java/me/lambdaurora/lambdacontrols/LambdaControls.java

@@ -1,251 +0,0 @@
-/*
- * Copyright © 2019 LambdAurora <aurora42lambda@gmail.com>
- *
- * This file is part of LambdaControls.
- *
- * Licensed under the MIT license. For more information,
- * see the LICENSE file.
- */
-
-package me.lambdaurora.lambdacontrols;
-
-import com.mojang.blaze3d.platform.GlStateManager;
-import net.fabricmc.api.ClientModInitializer;
-import net.fabricmc.fabric.api.client.keybinding.FabricKeyBinding;
-import net.fabricmc.fabric.api.client.keybinding.KeyBindingRegistry;
-import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.font.TextRenderer;
-import net.minecraft.client.gui.DrawableHelper;
-import net.minecraft.client.resource.language.I18n;
-import net.minecraft.client.toast.SystemToast;
-import net.minecraft.client.util.InputUtil;
-import net.minecraft.text.LiteralText;
-import net.minecraft.text.TranslatableText;
-import net.minecraft.util.Identifier;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.jetbrains.annotations.NotNull;
-import org.lwjgl.glfw.GLFW;
-
-/**
- * Represents the LambdaControls mod.
- */
-public class LambdaControls implements ClientModInitializer
-{
-    private static      LambdaControls       INSTANCE;
-    public static final FabricKeyBinding     BINDING_LOOK_UP    = FabricKeyBinding.Builder.create(new Identifier("lambdacontrols", "look_up"),
-            InputUtil.Type.KEYSYM, GLFW.GLFW_KEY_KP_8, "key.categories.movement").build();
-    public static final FabricKeyBinding     BINDING_LOOK_RIGHT = FabricKeyBinding.Builder.create(new Identifier("lambdacontrols", "look_right"),
-            InputUtil.Type.KEYSYM, GLFW.GLFW_KEY_KP_6, "key.categories.movement").build();
-    public static final FabricKeyBinding     BINDING_LOOK_DOWN  = FabricKeyBinding.Builder.create(new Identifier("lambdacontrols", "look_down"),
-            InputUtil.Type.KEYSYM, GLFW.GLFW_KEY_KP_2, "key.categories.movement").build();
-    public static final FabricKeyBinding     BINDING_LOOK_LEFT  = FabricKeyBinding.Builder.create(new Identifier("lambdacontrols", "look_left"),
-            InputUtil.Type.KEYSYM, GLFW.GLFW_KEY_KP_4, "key.categories.movement").build();
-    public static final Identifier           CONTROLLER_BUTTONS = new Identifier("lambdacontrols", "textures/gui/controller_buttons.png");
-    public static final Identifier           CONTROLLER_AXIS    = new Identifier("lambdacontrols", "textures/gui/controller_axis.png");
-    public final        Logger               logger             = LogManager.getLogger("LambdaControls");
-    public final        LambdaControlsConfig config             = new LambdaControlsConfig(this);
-    public final        LambdaInput          input              = new LambdaInput(this);
-    private             ControlsMode         previous_controls_mode;
-
-    @Override
-    public void onInitializeClient()
-    {
-        INSTANCE = this;
-        this.log("Initializing LambdaControls...");
-        this.config.load();
-
-        KeyBindingRegistry.INSTANCE.register(BINDING_LOOK_UP);
-        KeyBindingRegistry.INSTANCE.register(BINDING_LOOK_RIGHT);
-        KeyBindingRegistry.INSTANCE.register(BINDING_LOOK_DOWN);
-        KeyBindingRegistry.INSTANCE.register(BINDING_LOOK_LEFT);
-    }
-
-    /**
-     * This method is called when Minecraft is initializing.
-     */
-    public void on_mc_init(@NotNull MinecraftClient client)
-    {
-        Controller.update_mappings();
-        ButtonBinding.init(client.options);
-        GLFW.glfwSetJoystickCallback((jid, event) -> {
-            if (event == GLFW.GLFW_CONNECTED) {
-                Controller controller = Controller.by_id(jid);
-                client.getToastManager().add(new SystemToast(SystemToast.Type.TUTORIAL_HINT, new TranslatableText("lambdacontrols.controller.connected", jid),
-                        new LiteralText(controller.get_name())));
-            } else if (event == GLFW.GLFW_DISCONNECTED) {
-                client.getToastManager().add(new SystemToast(SystemToast.Type.TUTORIAL_HINT, new TranslatableText("lambdacontrols.controller.disconnected", jid),
-                        null));
-            }
-
-            this.switch_controls_mode();
-        });
-    }
-
-    /**
-     * This method is called every Minecraft tick.
-     *
-     * @param client The client instance.
-     */
-    public void on_tick(@NotNull MinecraftClient client)
-    {
-        this.input.on_tick(client);
-        if (this.config.get_controls_mode() == ControlsMode.CONTROLLER)
-            this.input.on_controller_tick(client);
-    }
-
-    public void on_render(MinecraftClient client)
-    {
-        this.input.on_render(client);
-    }
-
-    /**
-     * Switches the controls mode if the auto switch is enabled.
-     */
-    public void switch_controls_mode()
-    {
-        if (this.config.has_auto_switch_mode()) {
-            if (this.config.get_controller().is_gamepad()) {
-                this.previous_controls_mode = this.config.get_controls_mode();
-                this.config.set_controls_mode(ControlsMode.CONTROLLER);
-            } else {
-                if (this.previous_controls_mode == null) {
-                    this.previous_controls_mode = ControlsMode.DEFAULT;
-                }
-
-                this.config.set_controls_mode(this.previous_controls_mode);
-            }
-        }
-    }
-
-    /**
-     * Prints a message to the terminal.
-     *
-     * @param info The message to print.
-     */
-    public void log(String info)
-    {
-        this.logger.info("[LambdaControls] " + info);
-    }
-
-    /**
-     * Gets the LambdaControls instance.
-     *
-     * @return The LambdaControls instance.
-     */
-    public static LambdaControls get()
-    {
-        return INSTANCE;
-    }
-
-    public static int draw_button(int x, int y, @NotNull ButtonBinding button, @NotNull MinecraftClient client)
-    {
-        return draw_button(x, y, button.get_button(), client);
-    }
-
-    public static int draw_button(int x, int y, int button, @NotNull MinecraftClient client)
-    {
-        if (button == -1)
-            return 0;
-
-        int controller_type = get().config.get_controller_type().get_id();
-        boolean axis = false;
-        int button_offset = button * 15;
-        switch (button) {
-            case GLFW.GLFW_GAMEPAD_BUTTON_LEFT_BUMPER:
-                button_offset = 7 * 15;
-                break;
-            case GLFW.GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER:
-                button_offset = 8 * 15;
-                break;
-            case GLFW.GLFW_GAMEPAD_BUTTON_BACK:
-                button_offset = 4 * 15;
-                break;
-            case GLFW.GLFW_GAMEPAD_BUTTON_START:
-                button_offset = 6 * 15;
-                break;
-            case GLFW.GLFW_GAMEPAD_BUTTON_GUIDE:
-                button_offset = 5 * 15;
-                break;
-            case GLFW.GLFW_GAMEPAD_BUTTON_LEFT_THUMB:
-                button_offset = 15 * 15;
-                break;
-            case GLFW.GLFW_GAMEPAD_BUTTON_RIGHT_THUMB:
-                button_offset = 16 * 15;
-                break;
-            case GLFW.GLFW_GAMEPAD_AXIS_LEFT_X + 100:
-                button_offset = 0;
-                axis = true;
-                break;
-            case GLFW.GLFW_GAMEPAD_AXIS_LEFT_Y + 100:
-                button_offset = 18;
-                axis = true;
-                break;
-            case GLFW.GLFW_GAMEPAD_AXIS_RIGHT_X + 100:
-                button_offset = 2 * 18;
-                axis = true;
-                break;
-            case GLFW.GLFW_GAMEPAD_AXIS_RIGHT_Y + 100:
-                button_offset = 3 * 18;
-                axis = true;
-                break;
-            case GLFW.GLFW_GAMEPAD_AXIS_LEFT_X + 200:
-                button_offset = 4 * 18;
-                axis = true;
-                break;
-            case GLFW.GLFW_GAMEPAD_AXIS_LEFT_Y + 200:
-                button_offset = 5 * 18;
-                axis = true;
-                break;
-            case GLFW.GLFW_GAMEPAD_AXIS_RIGHT_X + 200:
-                button_offset = 6 * 18;
-                axis = true;
-                break;
-            case GLFW.GLFW_GAMEPAD_AXIS_RIGHT_Y + 200:
-                button_offset = 7 * 18;
-                axis = true;
-                break;
-            case GLFW.GLFW_GAMEPAD_AXIS_LEFT_TRIGGER + 100:
-            case GLFW.GLFW_GAMEPAD_AXIS_LEFT_TRIGGER + 200:
-                button_offset = 9 * 15;
-                break;
-            case GLFW.GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER + 100:
-            case GLFW.GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER + 200:
-                button_offset = 10 * 15;
-                break;
-        }
-
-        client.getTextureManager().bindTexture(axis ? LambdaControls.CONTROLLER_AXIS : LambdaControls.CONTROLLER_BUTTONS);
-        GlStateManager.disableDepthTest();
-
-        GlStateManager.color4f(1.0F, 1.0F, 1.0F, 1.0F);
-        DrawableHelper.blit(x, y, (float) button_offset, (float) (controller_type * (axis ? 18 : 15)), axis ? 18 : 15, axis ? 18 : 15, 256, 256);
-        GlStateManager.enableDepthTest();
-
-        return axis ? 18 : 15;
-    }
-
-    public static int draw_button_tip(int x, int y, @NotNull ButtonBinding button, boolean display, @NotNull MinecraftClient client)
-    {
-        return draw_button_tip(x, y, button.get_button(), button.get_translation_key(), display, client);
-    }
-
-    public static int draw_button_tip(int x, int y, int button, @NotNull String action, boolean display, @NotNull MinecraftClient client)
-    {
-        String translated_action = I18n.translate(action);
-
-        if (display) {
-            int button_width = draw_button(x, y, button, client);
-
-            int text_y = (15 - client.textRenderer.fontHeight) / 2;
-            client.textRenderer.drawWithShadow(translated_action, (float) (x + button_width + 5), (float) (y + text_y), 14737632);
-        }
-
-        return display ? get_button_tip_width(translated_action, client.textRenderer) : -10;
-    }
-
-    private static int get_button_tip_width(@NotNull String action, @NotNull TextRenderer text_renderer)
-    {
-        return 15 + 5 + text_renderer.getStringWidth(action);
-    }
-}