Release v1.6.1 for Minecraft 1.21.6+

Closes #17

.github/FUNDING.yml

@@ -0,0 +1 @@
+ko_fi: chylex

.gitignore

@@ -27,3 +27,4 @@ bin/
 # fabric
 
 run/
+logs/

Fabric/build.gradle.kts

@@ -0,0 +1,71 @@
+import net.fabricmc.loom.configuration.ide.RunConfigSettings
+import org.gradle.jvm.tasks.Jar
+
+val modId: String by project
+val modSides: String by project
+val minecraftVersion: String by project
+val fabricVersion: String by project
+
+plugins {
+	id("fabric-loom")
+}
+
+dependencies {
+	minecraft("com.mojang:minecraft:$minecraftVersion")
+	modImplementation("net.fabricmc:fabric-loader:$fabricVersion")
+	mappings(loom.officialMojangMappings())
+}
+
+loom {
+	runs {
+		val runJvmArgs: Set<String> by project
+		
+		configureEach {
+			runDir("../run")
+			vmArgs(runJvmArgs)
+			ideConfigGenerated(true)
+		}
+		
+		fun side(name: String, configure: RunConfigSettings.() -> Unit) {
+			if (modSides == "both" || modSides == name) {
+				named(name, configure)
+			}
+			else {
+				findByName(name)?.let(::remove)
+			}
+		}
+		
+		side("client") {
+			configName = "Fabric Client"
+			client()
+		}
+		
+		side("server") {
+			configName = "Fabric Server"
+			server()
+		}
+	}
+	
+	mixin {
+		defaultRefmapName.set("$modId.refmap.json")
+	}
+}
+
+tasks.processResources {
+	filesMatching("fabric.mod.json") {
+		expand(inputs.properties)
+	}
+}
+
+tasks.jar {
+	exclude("com/terraformersmc/modmenu/")
+}
+
+tasks.register<Jar>("uncompressedRemapJar") {
+	group = "fabric"
+	
+	from(tasks.remapJar.map { it.outputs.files.map(::zipTree) })
+	
+	archiveClassifier.set("uncompressed")
+	entryCompression = ZipEntryCompression.STORED // Reduces size of multiloader jar.
+}

Fabric/src/main/java/chylex/bettercontrols/BetterControlsMod.java

@@ -1,11 +1,12 @@
 package chylex.bettercontrols;
+
 import chylex.bettercontrols.config.BetterControlsConfig;
 import net.fabricmc.api.ClientModInitializer;
 import net.fabricmc.loader.api.FabricLoader;
 
-public final class BetterControlsMod implements ClientModInitializer{
+public final class BetterControlsMod implements ClientModInitializer {
-	public static final BetterControlsConfig config = BetterControlsConfig.load(FabricLoader.getInstance().getConfigDir().resolve("BetterControls.json"));
-	
 	@Override
-	public void onInitializeClient(){}
+	public void onInitializeClient() {
+		BetterControlsCommon.setConfig(BetterControlsConfig.load(FabricLoader.getInstance().getConfigDir().resolve("BetterControls.json")));
+	}
 }

Fabric/src/main/java/chylex/bettercontrols/compatibility/ModMenuSupport.java

@@ -0,0 +1,12 @@
+package chylex.bettercontrols.compatibility;
+
+import chylex.bettercontrols.gui.BetterControlsScreen;
+import com.terraformersmc.modmenu.api.ConfigScreenFactory;
+import com.terraformersmc.modmenu.api.ModMenuApi;
+
+public class ModMenuSupport implements ModMenuApi {
+	@Override
+	public ConfigScreenFactory<?> getModConfigScreenFactory() {
+		return BetterControlsScreen::new;
+	}
+}

Fabric/src/main/java/com/terraformersmc/modmenu/api/ConfigScreenFactory.java

@@ -0,0 +1,9 @@
+package com.terraformersmc.modmenu.api;
+
+import net.minecraft.client.gui.screens.Screen;
+
+@SuppressWarnings("unused")
+@FunctionalInterface
+public interface ConfigScreenFactory<S extends Screen> {
+	S create(Screen parent);
+}

Fabric/src/main/java/com/terraformersmc/modmenu/api/ModMenuApi.java

@@ -0,0 +1,8 @@
+package com.terraformersmc.modmenu.api;
+
+@SuppressWarnings("unused")
+public interface ModMenuApi {
+	default ConfigScreenFactory<?> getModConfigScreenFactory() {
+		return screen -> null;
+	}
+}

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

@@ -0,0 +1,36 @@
+{
+  "schemaVersion": 1,
+  "id": "${id}",
+  "name": "${name}",
+  "description": "${description}",
+  "version": "${version}",
+  "license": "${license}",
+  
+  "icon": "assets/${id}/logo.png",
+  
+  "authors": [
+    "${author}"
+  ],
+  
+  "contact": {
+    "homepage": "https://chylex.com",
+    "issues": "${issuesURL}",
+    "sources": "${sourcesURL}"
+  },
+  
+  "environment": "${sidesForFabric}",
+  "entrypoints": {
+    "client": [ "chylex.bettercontrols.BetterControlsMod" ],
+    "modmenu": [ "chylex.bettercontrols.compatibility.ModMenuSupport" ]
+  },
+  
+  "mixins": [{
+    "config": "${id}.mixins.json",
+    "environment": "${sidesForFabric}"
+  }],
+  
+  "depends": {
+    "fabricloader": ">=${minimumFabricVersion}",
+    "minecraft": ">=${minimumMinecraftVersion}"
+  }
+}

NeoForge/build.gradle.kts

@@ -0,0 +1,51 @@
+import net.neoforged.moddevgradle.dsl.RunModel
+
+val modId: String by project
+val modSides: String by project
+val neoForgeVersion: String by project
+
+plugins {
+	id("net.neoforged.moddev")
+}
+
+neoForge {
+	version = neoForgeVersion
+	
+	mods {
+		register(modId) {
+			sourceSet(sourceSets.main.get())
+			sourceSet(rootProject.sourceSets.main.get())
+		}
+	}
+	
+	runs {
+		val runJvmArgs: Set<String> by project
+		
+		configureEach {
+			gameDirectory = file("../run")
+			jvmArguments.addAll(runJvmArgs)
+		}
+		
+		fun side(name: String, configure: RunModel.() -> Unit) {
+			if (modSides == "both" || modSides == name) {
+				register(name, configure)
+			}
+		}
+		
+		side("client") {
+			ideName.set("NeoForge Client")
+			client()
+		}
+		
+		side("server") {
+			ideName.set("NeoForge Server")
+			server()
+		}
+	}
+}
+
+tasks.processResources {
+	filesMatching("META-INF/neoforge.mods.toml") {
+		expand(inputs.properties)
+	}
+}

NeoForge/src/main/java/chylex/bettercontrols/BetterControlsMod.java

@@ -0,0 +1,27 @@
+package chylex.bettercontrols;
+
+import chylex.bettercontrols.config.BetterControlsConfig;
+import chylex.bettercontrols.gui.BetterControlsScreen;
+import net.minecraft.client.gui.screens.Screen;
+import net.neoforged.api.distmarker.Dist;
+import net.neoforged.fml.ModContainer;
+import net.neoforged.fml.ModLoadingContext;
+import net.neoforged.fml.common.Mod;
+import net.neoforged.fml.loading.FMLEnvironment;
+import net.neoforged.fml.loading.FMLPaths;
+import net.neoforged.neoforge.client.gui.IConfigScreenFactory;
+import javax.annotation.Nullable;
+
+@Mod("bettercontrols")
+public final class BetterControlsMod {
+	public BetterControlsMod() {
+		if (FMLEnvironment.dist == Dist.CLIENT) {
+			BetterControlsCommon.setConfig(BetterControlsConfig.load(FMLPaths.CONFIGDIR.get().resolve("BetterControls.json")));
+			ModLoadingContext.get().registerExtensionPoint(IConfigScreenFactory.class, () -> BetterControlsMod::createOptionsScreen);
+		}
+	}
+	
+	private static BetterControlsScreen createOptionsScreen(ModContainer modContainer, @Nullable Screen parentScreen) {
+		return new BetterControlsScreen(parentScreen);
+	}
+}

NeoForge/src/main/resources/META-INF/neoforge.mods.toml

@@ -0,0 +1,31 @@
+modLoader = "javafml"
+loaderVersion = "[0,)"
+
+license = "${license}"
+issueTrackerURL = "${issuesURL}"
+
+[[mods]]
+modId = "${id}"
+displayName = "${name}"
+displayURL = "${sourcesURL}"
+description = "${description}"
+authors = "${author}"
+version = "${version}"
+logoFile = "assets/${id}/logo.png"
+
+[[mixins]]
+config = "${id}.mixins.json"
+
+[[dependencies.${id}]]
+modId = "minecraft"
+type = "required"
+versionRange = "[${minimumMinecraftVersion},)"
+ordering = "NONE"
+side = "${sidesForNeoForge}"
+
+[[dependencies.${id}]]
+modId = "neoforge"
+type = "required"
+versionRange = "[${minimumNeoForgeVersion},)"
+ordering = "NONE"
+side = "${sidesForNeoForge}"

README.md

@@ -1,3 +1,90 @@
-# Better Controls
+Better Controls
+===============
 
-WIP
+![Logo](https://raw.githubusercontent.com/chylex/Better-Controls/master/logo.png "Depiction of Zero Regrets")
+
+[Better Controls](https://www.curseforge.com/minecraft/mc-mods/better-controls) is a reimagining of [Better Sprinting](https://www.curseforge.com/minecraft/mc-mods/better-sprinting) with even more customizability. It features several new keybindings and many configurable options for how sprinting, sneaking, and flying should behave.
+
+Better Controls only focuses on complementing vanilla mechanics, rather than adding new mechanics (such as [Better Sprinting](https://www.curseforge.com/minecraft/mc-mods/better-sprinting)'s option to allow sprinting in all directions) that only work on client side and server owners must explicitly opt in to enable them. By not having such features in Better Controls, it significantly reduces complexity by not having a server side version of the mod, and not needing a way to completely disable the mod while the game is running.
+
+Another major difference is the amount and granularity of options. Better Controls could be considered an *advanced controls mod* - by default, none of the keybinds are bound, and all options are set to match vanilla behavior. To take full advantage, go into *Options - Controls - Better Controls*, check out all of the available options, and figure out the best configuration for you.
+
+## Features
+
+The mod adds **Toggle Keybinds** for sprinting, sneaking, flying (creative mode), walking, and jumping. You can use modifier keys (`Control` / `Shift` / `Alt`) for each, including for example setting `Control` to Sneak, and `Control + Y` to Toggle Sneak. If you press the original key, the toggle will be canceled (in the previous example, you can Toggle Sneak by pressing `Control + Y`, and stop sneaking by simply tapping `Control`). Note that the vanilla options for toggling sprinting/sneaking are disabled to avoid conflicts with the custom keybinds.
+
+You can also bind a key that resets all **Toggle Keybinds** at once. That makes it easy to for ex. turn on walking, jumping, and sprinting, and then turn all of them off again by pressing one key instead of three.
+
+#### Sprinting
+
+* **Sprint Key Mode** changes how the Sprint key behaves. You can choose between *Tap To Start Sprinting*, *Tap To Start / Stop Sprinting*, and *Hold To Sprint*.
+* **Double Tap 'Walk Forwards' To Sprint** can be turned off.
+* **Resume Sprinting After Hitting Obstacle** re-activates sprinting once you are no longer touching any blocks.
+
+#### Sneaking
+
+* **Move Camera Smoothly** can be turned off to disable the smooth movement when sneaking or unsneaking.
+
+#### Gliding
+
+* **Start a Glide** with a dedicated key.
+* **Double Tap 'Jump' To Glide** can be turned off.
+
+#### Flying
+
+* **Double Tap 'Jump' To Fly** can be turned off.
+* **Flight Inertia Multiplier** changes how quickly you stop moving in the air when you stop holding movement keys.
+* **Disable Field Of View Changing** prevents sprinting, potions, and other factors from changing the FOV while flying in creative and spectator mode.
+* **Fly On Ground** lets you fly while touching the ground in creative mode. Stop flying by tapping Sneak while touching the ground.
+* **Flight Speed Multiplier** (0.25x - 8x) changes flight speed in creative and spectator mode.
+* **Vertical Speed Boost** (up to +300%) adds additional vertical flight speed boost in creative and spectator mode.
+
+Both speed boosts can be configured separately for sprinting, which will be active when the Sprint key is held. Unlike in vanilla, the sprinting flight boost works in all directions.
+
+## Installation
+
+The following mod loaders are supported:
+
+* **[Fabric](https://fabricmc.net/use/)** (note: this mod does not require Fabric API)
+* **[NeoForge](https://neoforged.net/)**
+
+After you install the mod loader of your choice, download the mod from [CurseForge](https://www.curseforge.com/minecraft/mc-mods/better-controls/files) or [Modrinth](https://modrinth.com/mod/better-controls/versions) and place the `.jar` file into `.minecraft/mods`.
+
+### Minecraft Updates
+
+The mod will attempt to load on new versions of Minecraft (including snapshots) as they come out. I made it that way so that if the mod works on a newly released version of Minecraft without any changes, I can simply mark it as compatible and you don't have to wait for an update.
+
+While this is convenient, there is potential for bugs which can affect server play. If you plan to use the mod on a server, please always use the latest version of the mod, and wait until I either mark the version as compatible with new Minecraft updates, or release a new version of the mod that is marked as compatible.
+
+### Compatibility
+
+* Better Controls is a client-side mod, it will do nothing when installed on a server.
+* If you run into a conflict with another mod that modifies the *Controls* screen, hold Alt while opening *Controls* to prevent Better Controls from adding its button. If another mod prevents the button from appearing, a button to open the mod's configuration is available in the Mods menu (for Fabric, install [Mod Menu](https://www.curseforge.com/minecraft/mc-mods/modmenu)).
+
+## Screenshot
+
+![Options Menu Screenshot](https://repo.chylex.com/better-controls.png)
+
+Source Code
+===========
+
+The `main` branch includes both the Fabric and NeoForge version in a single project. The project uses Mojang mappings. The root project contains common source code and resource files, and the `Fabric` and `NeoForge` folders are subprojects with loader-specific files.
+
+The `main` branch always has the latest development version. Before updating to a new Minecraft version, a new branch is created from the `main` branch (for example, before the mod is updated to `1.18`, a branch named `1.17` will be created). Further development of older versions may continue in these branches in case backports or version-specific fixes are needed.
+
+Older versions from before the merge of the Fabric and Forge versions can be found in branches named `fabric/<version>` and `forge/<version>`.
+
+## Contributing
+
+All contributions should target the `main` branch and work in both Fabric and NeoForge, unless the contribution is specifically targeting older versions or a specific mod loader.
+
+For any larger contributions, please [open an issue](https://github.com/chylex/Better-Controls/issues/new) first before you make a PR.
+
+Please keep in mind that this mod is designed to be very simple and easy to test. Over the years, [Better Sprinting](https://github.com/chylex/Better-Sprinting) has gained a fair amount of bloat that requires extensive testing before every release, and it is the reason why I will not be accepting PRs which add:
+
+* **Translations**
+  * If you want to translate the mod, you are welcome to create a separate version of it. Unfortunately, I've always ran into enough problems with maintaining and testing community mod translations that I will not be adding official support for localization.
+* **Server-side code**
+  * Better Controls will always be exclusively client-side. The server-side support in Better Sprinting is a major time sink which requires testing 3 separate client/server configurations per mod loader, and is the main reason I decided to drop support in favor of this mod.
+* **Singleplayer-only features**
+  * Better Controls intends to add accessibility options that can be used on servers, so features that only work in singleplayer or anything that could be used for cheating on servers will not be accepted.

build.gradle

@@ -1,40 +0,0 @@
-plugins {
-	id 'fabric-loom' version '0.5-SNAPSHOT'
-	id 'maven-publish'
-}
-
-sourceCompatibility = JavaVersion.VERSION_1_8
-targetCompatibility = JavaVersion.VERSION_1_8
-
-archivesBaseName = project.archives_base_name
-version = project.mod_version
-group = project.maven_group
-
-dependencies {
-	minecraft "com.mojang:minecraft:${project.minecraft_version}"
-	mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
-	modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
-	// modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
-}
-
-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"
-	}
-}
-
-tasks.withType(JavaCompile) {
-	options.encoding = "UTF-8"
-}
-
-jar {
-	from "LICENSE"
-	exclude "io/github/prospector/"
-}

build.gradle.kts

@@ -0,0 +1,217 @@
+@file:Suppress("ConvertLambdaToReference")
+
+import org.gradle.jvm.tasks.Jar
+
+val modId: String by project
+val modName: String by project
+val modDescription: String by project
+val modAuthor: String by project
+val modVersion: String by project
+val modLicense: String by project
+val modSourcesURL: String by project
+val modIssuesURL: String by project
+val modSides: String by project
+
+val minecraftVersion: String by project
+val mixinVersion: String by project
+val mixinExtrasVersion: String by project
+
+val minimumMinecraftVersion: String by project
+val minimumNeoForgeVersion: String by project
+val minimumFabricVersion: String by project
+
+val modNameStripped = modName.replace(" ", "")
+
+plugins {
+	idea
+	`java-library`
+	id("fabric-loom")
+}
+
+idea {
+	module {
+		excludeDirs.add(file("gradle"))
+		excludeDirs.add(file("run"))
+		
+		if (findProject(":NeoForge") == null) {
+			excludeDirs.add(file("NeoForge"))
+		}
+		
+		if (findProject(":Fabric") == null) {
+			excludeDirs.add(file("Fabric"))
+		}
+	}
+}
+
+repositories {
+	mavenCentral()
+}
+
+base {
+	archivesName.set("$modNameStripped-Common")
+}
+
+loom {
+	runs {
+		named("client") {
+			ideConfigGenerated(false)
+		}
+		
+		findByName("server")?.let(::remove)
+	}
+}
+
+dependencies {
+	minecraft("com.mojang:minecraft:$minecraftVersion")
+	mappings(loom.officialMojangMappings())
+	
+	compileOnly("net.fabricmc:sponge-mixin:$mixinVersion")
+	compileOnly("io.github.llamalad7:mixinextras-common:$mixinExtrasVersion")
+	
+	api("com.google.code.findbugs:jsr305:3.0.2")
+}
+
+allprojects {
+	group = "com.$modAuthor.$modId"
+	version = modVersion
+	
+	apply(plugin = "java-library")
+	
+	extensions.getByType<JavaPluginExtension>().apply {
+		toolchain.languageVersion.set(JavaLanguageVersion.of(21))
+	}
+	
+	tasks.withType<JavaCompile> {
+		options.encoding = "UTF-8"
+		options.release.set(21)
+	}
+	
+	val runJvmArgs = mutableSetOf<String>().also {
+		extra["runJvmArgs"] = it
+	}
+	
+	if (project.javaToolchains.launcherFor(java.toolchain).map { it.metadata.vendor }.orNull == "JetBrains") {
+		runJvmArgs.add("-XX:+AllowEnhancedClassRedefinition")
+	}
+	
+	dependencies {
+		implementation("org.jetbrains:annotations:24.1.0")
+	}
+	
+	tasks.withType<ProcessResources> {
+		val (sidesForNeoForge, sidesForFabric) = when (modSides) {
+			"both"   -> Pair("BOTH", "*")
+			"client" -> Pair("CLIENT", "client")
+			"server" -> Pair("SERVER", "server")
+			else     -> error("Invalid modSides value: $modSides")
+		}
+		
+		inputs.property("id", modId)
+		inputs.property("name", modName)
+		inputs.property("description", modDescription)
+		inputs.property("version", modVersion)
+		inputs.property("author", modAuthor)
+		inputs.property("license", modLicense)
+		inputs.property("sourcesURL", modSourcesURL)
+		inputs.property("issuesURL", modIssuesURL)
+		inputs.property("sidesForNeoForge", sidesForNeoForge)
+		inputs.property("sidesForFabric", sidesForFabric)
+		inputs.property("minimumMinecraftVersion", minimumMinecraftVersion)
+		inputs.property("minimumNeoForgeVersion", minimumNeoForgeVersion)
+		inputs.property("minimumFabricVersion", minimumFabricVersion)
+		
+		from(rootProject.file("logo.png")) {
+			into("assets/$modId")
+		}
+	}
+	
+	tasks.withType<AbstractArchiveTask>().configureEach {
+		isPreserveFileTimestamps = false
+		isReproducibleFileOrder = true
+	}
+}
+
+subprojects {
+	dependencies {
+		implementation(project(rootProject.path, configuration = "namedElements"))
+	}
+	
+	base {
+		archivesName.set("$modNameStripped-${project.name}")
+	}
+	
+	tasks.compileJava {
+		source({ rootProject.sourceSets.main.get().allSource })
+	}
+	
+	tasks.processResources {
+		from(rootProject.sourceSets.main.get().resources) {
+			expand(inputs.properties)
+		}
+	}
+	
+	tasks.jar {
+		entryCompression = ZipEntryCompression.STORED // Reduces size of multiloader jar.
+		
+		manifest {
+			packageInformation(modId, "$modNameStripped-${project.name}")
+		}
+	}
+	
+	tasks.test {
+		onlyIf { false }
+	}
+}
+
+fun Manifest.packageInformation(specificationTitle: String, implementationTitle: String) {
+	attributes(
+		"Specification-Title" to specificationTitle,
+		"Specification-Vendor" to modAuthor,
+		"Specification-Version" to "1",
+		"Implementation-Title" to implementationTitle,
+		"Implementation-Vendor" to modAuthor,
+		"Implementation-Version" to modVersion,
+	)
+}
+
+val multiloaderSources = sourceSets.register("multiloader")
+
+val multiloaderJar = tasks.register<Jar>("multiloaderJar") {
+	group = "build"
+	
+	archiveBaseName.set(modNameStripped)
+	archiveVersion.set("$minecraftVersion+v$modVersion")
+	
+	destinationDirectory = layout.buildDirectory.dir("dist")
+	
+	fun includeJar(project: Project, jarTaskName: String) {
+		from(project.tasks.named(jarTaskName).map { it.outputs }) {
+			into("jars")
+			rename { "$modNameStripped-${project.name}.jar" }
+		}
+	}
+	
+	findProject(":NeoForge")?.let { includeJar(it, "jar") }
+	findProject(":Fabric")?.let { includeJar(it, "uncompressedRemapJar") }
+	
+	from(rootProject.file("LICENSE"))
+	from(multiloaderSources.map { it.output })
+	
+	manifest {
+		packageInformation("$modId-multiloader", modNameStripped)
+		attributes("FMLModType" to "GAMELIBRARY")
+	}
+}
+
+tasks.named<ProcessResources>("processMultiloaderResources").configure {
+	inputs.property("group", project.group)
+	inputs.property("jarPrefix", modNameStripped)
+	
+	filesMatching(listOf("fabric.mod.json", "META-INF/jarjar/metadata.json")) {
+		expand(inputs.properties)
+	}
+}
+
+tasks.assemble {
+	finalizedBy(multiloaderJar)
+}

docs/CURSEFORGE.md

@@ -0,0 +1,61 @@
+**Better Controls** is a reimagining of [Better Sprinting](https://www.curseforge.com/minecraft/mc-mods/better-sprinting) with even more customizability. It features several new keybindings and many configurable options for how sprinting, sneaking, and flying should behave.
+
+Better Controls only focuses on complementing vanilla mechanics, rather than adding new mechanics (such as [Better Sprinting](https://www.curseforge.com/minecraft/mc-mods/better-sprinting)'s option to allow sprinting in all directions) that only work on client side and server owners must explicitly opt in to enable them. By not having such features in Better Controls, it significantly reduces complexity by not having a server side version of the mod, and not needing a way to completely disable the mod while the game is running.
+
+Another major difference is the amount and granularity of options. Better Controls could be considered an *advanced controls mod* - by default, none of the keybinds are bound, and all options are set to match vanilla behavior. To take full advantage, go into *Options - Controls - Better Controls*, check out all of the available options, and figure out the best configuration for you.
+
+## Features
+
+The mod adds **Toggle Keybinds** for sprinting, sneaking, flying (creative mode), walking, and jumping. You can use modifier keys (`Control` / `Shift` / `Alt`) for each, including for example setting `Control` to Sneak, and `Control + Y` to Toggle Sneak. If you press the original key, the toggle will be canceled (in the previous example, you can Toggle Sneak by pressing `Control + Y`, and stop sneaking by simply tapping `Control`). Note that the vanilla options for toggling sprinting/sneaking are disabled to avoid conflicts with the custom keybinds.
+
+You can also bind a key that resets all **Toggle Keybinds** at once. That makes it easy to for ex. turn on walking, jumping, and sprinting, and then turn all of them off again by pressing one key instead of three.
+
+#### Sprinting
+
+* **Sprint Key Mode** changes how the Sprint key behaves. You can choose between *Tap To Start Sprinting*, *Tap To Start / Stop Sprinting*, and *Hold To Sprint*.
+* **Double Tap 'Walk Forwards' To Sprint** can be turned off.
+* **Resume Sprinting After Hitting Obstacle** re-activates sprinting once you are no longer touching any blocks.
+
+#### Sneaking
+
+* **Move Camera Smoothly** can be turned off to disable the smooth movement when sneaking or unsneaking.
+
+#### Gliding
+
+* **Start a Glide** with a dedicated key.
+* **Double Tap 'Jump' To Glide** can be turned off.
+
+#### Flying
+
+* **Double Tap 'Jump' To Fly** can be turned off.
+* **Flight Inertia Multiplier** changes how quickly you stop moving in the air when you stop holding movement keys.
+* **Disable Field Of View Changing** prevents sprinting, potions, and other factors from changing the FOV while flying in creative and spectator mode.
+* **Fly On Ground** lets you fly while touching the ground in creative mode. Stop flying by tapping Sneak while touching the ground.
+* **Flight Speed Multiplier** (0.25x - 8x) changes flight speed in creative and spectator mode.
+* **Vertical Speed Boost** (up to +300%) adds additional vertical flight speed boost in creative and spectator mode.
+
+Both speed boosts can be configured separately for sprinting, which will be active when the Sprint key is held. Unlike in vanilla, the sprinting flight boost works in all directions.
+
+## Installation
+
+The following mod loaders are supported:
+
+* **[Fabric](https://fabricmc.net/use/)** (note: this mod does not require Fabric API)
+* **[NeoForge](https://neoforged.net/)**
+
+After you install the mod loader of your choice, [download the mod](https://www.curseforge.com/minecraft/mc-mods/better-controls/files) and place the `.jar` file into `.minecraft/mods`.
+
+### Minecraft Updates
+
+The mod will attempt to load on new versions of Minecraft (including snapshots) as they come out. I made it that way so that if the mod works on a newly released version of Minecraft without any changes, I can simply mark it as compatible and you don't have to wait for an update.
+
+While this is convenient, there is potential for bugs which can affect server play. If you plan to use the mod on a server, please always use the latest version of the mod, and wait until I either mark the version as compatible with new Minecraft updates, or release a new version of the mod that is marked as compatible.
+
+### Compatibility
+
+* Better Controls is a client-side mod, it will do nothing when installed on a server.
+* If you run into a conflict with another mod that modifies the *Controls* screen, hold Alt while opening *Controls* to prevent Better Controls from adding its button. If another mod prevents the button from appearing, a button to open the mod's configuration is available in the Mods menu (for Fabric, install [Mod Menu](https://www.curseforge.com/minecraft/mc-mods/modmenu)).
+
+## Screenshot
+
+![Options Menu Screenshot](https://repo.chylex.com/better-controls.png)

docs/MODRINTH.md

@@ -0,0 +1,61 @@
+**Better Controls** is a reimagining of [Better Sprinting](https://modrinth.com/mod/better-sprinting) with even more customizability. It features several new keybindings and many configurable options for how sprinting, sneaking, and flying should behave.
+
+Better Controls only focuses on complementing vanilla mechanics, rather than adding new mechanics (such as [Better Sprinting](https://modrinth.com/mod/better-sprinting)'s option to allow sprinting in all directions) that only work on client side and server owners must explicitly opt in to enable them. By not having such features in Better Controls, it significantly reduces complexity by not having a server side version of the mod, and not needing a way to completely disable the mod while the game is running.
+
+Another major difference is the amount and granularity of options. Better Controls could be considered an *advanced controls mod* - by default, none of the keybinds are bound, and all options are set to match vanilla behavior. To take full advantage, go into *Options - Controls - Better Controls*, check out all of the available options, and figure out the best configuration for you.
+
+## Features
+
+The mod adds **Toggle Keybinds** for sprinting, sneaking, flying (creative mode), walking, and jumping. You can use modifier keys (`Control` / `Shift` / `Alt`) for each, including for example setting `Control` to Sneak, and `Control + Y` to Toggle Sneak. If you press the original key, the toggle will be canceled (in the previous example, you can Toggle Sneak by pressing `Control + Y`, and stop sneaking by simply tapping `Control`). Note that the vanilla options for toggling sprinting/sneaking are disabled to avoid conflicts with the custom keybinds.
+
+You can also bind a key that resets all **Toggle Keybinds** at once. That makes it easy to for ex. turn on walking, jumping, and sprinting, and then turn all of them off again by pressing one key instead of three.
+
+#### Sprinting
+
+* **Sprint Key Mode** changes how the Sprint key behaves. You can choose between *Tap To Start Sprinting*, *Tap To Start / Stop Sprinting*, and *Hold To Sprint*.
+* **Double Tap 'Walk Forwards' To Sprint** can be turned off.
+* **Resume Sprinting After Hitting Obstacle** re-activates sprinting once you are no longer touching any blocks.
+
+#### Sneaking
+
+* **Move Camera Smoothly** can be turned off to disable the smooth movement when sneaking or unsneaking.
+
+#### Gliding
+
+* **Start a Glide** with a dedicated key.
+* **Double Tap 'Jump' To Glide** can be turned off.
+
+#### Flying
+
+* **Double Tap 'Jump' To Fly** can be turned off.
+* **Flight Inertia Multiplier** changes how quickly you stop moving in the air when you stop holding movement keys.
+* **Disable Field Of View Changing** prevents sprinting, potions, and other factors from changing the FOV while flying in creative and spectator mode.
+* **Fly On Ground** lets you fly while touching the ground in creative mode. Stop flying by tapping Sneak while touching the ground.
+* **Flight Speed Multiplier** (0.25x - 8x) changes flight speed in creative and spectator mode.
+* **Vertical Speed Boost** (up to +300%) adds additional vertical flight speed boost in creative and spectator mode.
+
+Both speed boosts can be configured separately for sprinting, which will be active when the Sprint key is held. Unlike in vanilla, the sprinting flight boost works in all directions.
+
+## Installation
+
+The following mod loaders are supported:
+
+* **[Fabric](https://fabricmc.net/use/)** (note: this mod does not require Fabric API)
+* **[NeoForge](https://neoforged.net/)**
+
+After you install the mod loader of your choice, [download the mod](https://modrinth.com/mod/better-controls/versions) and place the `.jar` file into `.minecraft/mods`.
+
+### Minecraft Updates
+
+The mod will attempt to load on new versions of Minecraft (including snapshots) as they come out. I made it that way so that if the mod works on a newly released version of Minecraft without any changes, I can simply mark it as compatible and you don't have to wait for an update.
+
+While this is convenient, there is potential for bugs which can affect server play. If you plan to use the mod on a server, please always use the latest version of the mod, and wait until I either mark the version as compatible with new Minecraft updates, or release a new version of the mod that is marked as compatible.
+
+### Compatibility
+
+* Better Controls is a client-side mod, it will do nothing when installed on a server.
+* If you run into a conflict with another mod that modifies the *Controls* screen, hold Alt while opening *Controls* to prevent Better Controls from adding its button. If another mod prevents the button from appearing, a button to open the mod's configuration is available in the Mods menu (for Fabric, install [Mod Menu](https://modrinth.com/mod/modmenu)).
+
+## Screenshot
+
+![Options Menu Screenshot](https://cdn.modrinth.com/data/ANpj0aBF/images/9fed66f9f60a8d880fba24f5333ed7e11d1a7ae2.png)

gradle.properties

@@ -1,18 +1,33 @@
-# Done to increase the memory available to gradle.
+# Mod
-org.gradle.jvmargs=-Xmx1G
+modId=bettercontrols
-
+modName=Better Controls
-# Fabric Properties
+modDescription=Adds many powerful key bindings and options to control your movement.\\n\\nThe features complement vanilla mechanics without giving unfair advantages, so server use should be fine.
-minecraft_version=1.16.3
+modAuthor=chylex
-yarn_mappings=1.16.3+build.47
+modVersion=1.6.1
-loader_version=0.10.2+build.210
+modLicense=MPL-2.0
-
+modSourcesURL=https://github.com/chylex/Better-Controls
-# Mod Properties
+modIssuesURL=https://github.com/chylex/Better-Controls/issues
-mod_version=1.0.0
+modSides=client
-maven_group=chylex.bettercontrols
-archives_base_name=BetterControls
 
 # Dependencies
-fabric_version=0.22.0+build.408-1.16
+minecraftVersion=1.21.6
+neoForgeVersion=21.6.20-beta
+neoModDevVersion=2.0.103
+fabricVersion=0.16.14
+loomVersion=1.10
+mixinVersion=0.12.5+mixin.0.8.5
+mixinExtrasVersion=0.4.1
 
-# https://fabricmc.net/use
+# https://projects.neoforged.net/neoforged/neoforge
-# https://maven.fabricmc.net/net/fabricmc/fabric-api/fabric-api
+# https://projects.neoforged.net/neoforged/moddevgradle
+# https://fabricmc.net/develop/
+# https://github.com/FabricMC/fabric-loom/releases
+
+# Constraints
+minimumMinecraftVersion=1.21.6
+minimumNeoForgeVersion=21.6.0-beta
+minimumFabricVersion=0.15.0
+
+# Gradle
+org.gradle.jvmargs=-Xmx3G
+org.gradle.daemon=false

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.6.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.12.1-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
+#!/bin/sh
 
 #
-# Copyright 2015 the original author or authors.
+# Copyright © 2015-2021 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,69 +15,103 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
-##
+#
-##  Gradle start up script for UN*X
+#   Gradle start up script for POSIX generated by Gradle.
-##
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
+app_path=$0
-# Need this for relative symlinks.
+
-while [ -h "$PRG" ] ; do
+# Need this for daisy-chained symlinks.
-    ls=`ls -ld "$PRG"`
+while
-    link=`expr "$ls" : '.*-> \(.*\)$'`
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    if expr "$link" : '/.*' > /dev/null; then
+    [ -h "$app_path" ]
-        PRG="$link"
+do
-    else
+    ls=$( ls -ld "$app_path" )
-        PRG=`dirname "$PRG"`"/$link"
+    link=${ls#*' -> '}
-    fi
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
 
-APP_NAME="Gradle"
+# This is normally unused
-APP_BASE_NAME=`basename "$0"`
+# shellcheck disable=SC2034
-
+APP_BASE_NAME=${0##*/}
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
+case "$( uname )" in                #(
-  CYGWIN* )
+  CYGWIN* )         cygwin=true  ;; #(
-    cygwin=true
+  Darwin* )         darwin=true  ;; #(
-    ;;
+  MSYS* | MINGW* )  msys=true    ;; #(
-  Darwin* )
+  NONSTOP* )        nonstop=true ;;
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
@@ -87,9 +121,9 @@ CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -98,88 +132,120 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
+    JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
+    case $MAX_FD in #(
-    if [ $? -eq 0 ] ; then
+      max*)
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-            MAX_FD="$MAX_FD_LIMIT"
+        # shellcheck disable=SC2039,SC3045
-        fi
+        MAX_FD=$( ulimit -H -n ) ||
-        ulimit -n $MAX_FD
+            warn "Could not query maximum file descriptor limit"
-        if [ $? -ne 0 ] ; then
+    esac
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
+    case $MAX_FD in  #(
-        fi
+      '' | soft) :;; #(
-    else
+      *)
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-    fi
+        # shellcheck disable=SC2039,SC3045
-fi
+        ulimit -n "$MAX_FD" ||
-
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# 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
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        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" ;;
     esac
 fi
 
-# Escape application args
+# Collect all arguments for the java command, stacking in reverse order:
-save () {
+#   * args from the command line
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+#   * the main class name
-    echo " "
+#   * -classpath
-}
+#   * -D...appname settings
-APP_ARGS=`save "$@"`
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
+# For Cygwin or MSYS, switch paths to Windows format before running java
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
 
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -13,8 +13,10 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
-@if "%DEBUG%" == "" @echo off
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -25,7 +27,8 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
@@ -40,13 +43,13 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if %ERRORLEVEL% equ 0 goto execute
 
-echo.
+echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo.
+echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation.
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -54,31 +57,16 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
-echo.
+echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo.
+echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation.
+echo location of your Java installation. 1>&2
 
 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
 
@@ -86,17 +74,19 @@ 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%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 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
+set EXIT_CODE=%ERRORLEVEL%
-exit /b 1
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

settings.gradle

@@ -1,10 +0,0 @@
-pluginManagement {
-	repositories {
-		jcenter()
-		maven {
-			name = 'Fabric'
-			url = 'https://maven.fabricmc.net/'
-		}
-		gradlePluginPortal()
-	}
-}

settings.gradle.kts

@@ -0,0 +1,29 @@
+rootProject.name = "Better-Controls"
+
+pluginManagement {
+	repositories {
+		gradlePluginPortal()
+		maven(url = "https://maven.neoforged.net/releases") { name = "NeoForge" }
+		maven(url = "https://maven.fabricmc.net/") { name = "Fabric" }
+	}
+	
+	plugins {
+		val neoModDevVersion = settings.extra.get("neoModDevVersion") as? String
+		if (neoModDevVersion != null) {
+			id("net.neoforged.moddev") version neoModDevVersion
+		}
+		
+		val loomVersion = settings.extra.get("loomVersion") as? String
+		if (loomVersion != null) {
+			id("fabric-loom") version "$loomVersion-SNAPSHOT"
+		}
+	}
+}
+
+if (settings.extra.has("neoForgeVersion")) {
+	include("NeoForge")
+}
+
+if (settings.extra.has("fabricVersion")) {
+	include("Fabric")
+}

src/main/java/chylex/bettercontrols/BetterControlsCommon.java

@@ -0,0 +1,17 @@
+package chylex.bettercontrols;
+
+import chylex.bettercontrols.config.BetterControlsConfig;
+
+public final class BetterControlsCommon {
+	private static BetterControlsConfig config;
+	
+	public static BetterControlsConfig getConfig() {
+		return config;
+	}
+	
+	static void setConfig(BetterControlsConfig config) {
+		BetterControlsCommon.config = config;
+	}
+	
+	private BetterControlsCommon() {}
+}

src/main/java/chylex/bettercontrols/Mixins.java

@@ -0,0 +1,42 @@
+package chylex.bettercontrols;
+
+import chylex.bettercontrols.mixin.AccessCameraFields;
+import chylex.bettercontrols.mixin.AccessClientPlayerFields;
+import chylex.bettercontrols.mixin.AccessKeyMappingFields;
+import chylex.bettercontrols.mixin.AccessPlayerFields;
+import chylex.bettercontrols.mixin.AccessToggleKeyMappingFields;
+import net.minecraft.client.Camera;
+import net.minecraft.client.KeyMapping;
+import net.minecraft.client.ToggleKeyMapping;
+import net.minecraft.client.player.LocalPlayer;
+import net.minecraft.world.entity.player.Player;
+
+@SuppressWarnings("CastToIncompatibleInterface")
+public final class Mixins {
+	private Mixins() {}
+	
+	@SuppressWarnings("unchecked")
+	public static <T> T me(Object object) {
+		return (T) object;
+	}
+	
+	public static AccessCameraFields cameraFields(Camera camera) {
+		return (AccessCameraFields) camera;
+	}
+	
+	public static AccessClientPlayerFields clientPlayerFields(LocalPlayer localPlayer) {
+		return (AccessClientPlayerFields) localPlayer;
+	}
+	
+	public static AccessKeyMappingFields keyMappingFields(KeyMapping keyMapping) {
+		return (AccessKeyMappingFields) keyMapping;
+	}
+	
+	public static AccessPlayerFields playerFields(Player player) {
+		return (AccessPlayerFields) player;
+	}
+	
+	public static AccessToggleKeyMappingFields toggleKeyMappingFields(ToggleKeyMapping toggleKeyMapping) {
+		return (AccessToggleKeyMappingFields) toggleKeyMapping;
+	}
+}

src/main/java/chylex/bettercontrols/compatibility/ModMenuSupport.java

@@ -1,11 +0,0 @@
-package chylex.bettercontrols.compatibility;
-import chylex.bettercontrols.gui.BetterControlsScreen;
-import io.github.prospector.modmenu.api.ConfigScreenFactory;
-import io.github.prospector.modmenu.api.ModMenuApi;
-
-public class ModMenuSupport implements ModMenuApi{
-	@Override
-	public ConfigScreenFactory<?> getModConfigScreenFactory(){
-		return BetterControlsScreen::new;
-	}
-}

src/main/java/chylex/bettercontrols/config/BetterControlsConfig.java

@@ -1,53 +1,69 @@
 package chylex.bettercontrols.config;
+
 import chylex.bettercontrols.input.KeyBindingWithModifier;
-import net.minecraft.client.options.KeyBinding;
+import chylex.bettercontrols.input.SprintMode;
 import java.nio.file.Path;
 
-public final class BetterControlsConfig{
+public final class BetterControlsConfig {
-	public static BetterControlsConfig load(final Path path){
+	public static BetterControlsConfig load(Path path) {
-		return ConfigSerializer.deserialize(path).setPath(path);
+		BetterControlsConfig cfg = ConfigSerializer.read(path);
+		cfg.path = path;
+		
+		if (cfg.wasMigrated) {
+			cfg.save();
+		}
+		
+		return cfg;
 	}
 	
 	private Path path;
+	boolean wasMigrated = false;
 	
 	public final KeyBindingWithModifier keyToggleSprint = new KeyBindingWithModifier("key.bettercontrols.toggle_sprint");
+	public SprintMode sprintMode = SprintMode.TAP_TO_START;
 	public boolean doubleTapForwardToSprint = true;
-	public boolean tapSprintKeyAgainToStopSprinting = false;
 	public boolean resumeSprintingAfterHittingObstacle = false;
 	
 	public final KeyBindingWithModifier keyToggleSneak = new KeyBindingWithModifier("key.bettercontrols.toggle_sneak");
 	public boolean sneakingMovesCameraSmoothly = true;
 	
+	public final KeyBindingWithModifier keyStartGlide = new KeyBindingWithModifier("key.bettercontrols.start_glide");
+	public boolean doubleTapJumpToGlide = true;
+	
 	public final KeyBindingWithModifier keyToggleFlight = new KeyBindingWithModifier("key.bettercontrols.toggle_flight");
+	public boolean doubleTapJumpToToggleFlight = true;
+	public float flightInertiaMultiplier = 1F;
+	public boolean disableChangingFovWhileFlying = false;
 	public boolean flyOnGroundInCreative = false;
-	public float flightSpeedMpCreativeDefault = 1F;
+	public float flightHorizontalSpeedMpCreativeDefault = 1F;
-	public float flightSpeedMpCreativeSprinting = 2F;
+	public float flightHorizontalSpeedMpCreativeSprinting = 2F;
-	public float flightSpeedMpSpectatorDefault = 1F;
+	public float flightHorizontalSpeedMpSpectatorDefault = 1F;
-	public float flightSpeedMpSpectatorSprinting = 2F;
+	public float flightHorizontalSpeedMpSpectatorSprinting = 2F;
+	public float flightVerticalSpeedMpCreativeDefault = 1F;
+	public float flightVerticalSpeedMpCreativeSprinting = 2F;
+	public float flightVerticalSpeedMpSpectatorDefault = 1F;
+	public float flightVerticalSpeedMpSpectatorSprinting = 2F;
 	
 	public final KeyBindingWithModifier keyToggleWalkForward = new KeyBindingWithModifier("key.bettercontrols.toggle_forward");
 	public final KeyBindingWithModifier keyToggleJump = new KeyBindingWithModifier("key.bettercontrols.toggle_jump");
+	public final KeyBindingWithModifier keyResetAllToggles = new KeyBindingWithModifier("key.bettercontrols.reset_all_toggles");
 	public final KeyBindingWithModifier keyOpenMenu = new KeyBindingWithModifier("key.bettercontrols.open_menu");
 	
-	BetterControlsConfig(){}
+	BetterControlsConfig() {}
 	
-	private BetterControlsConfig setPath(final Path path){
+	public KeyBindingWithModifier[] getAllKeyBindings() {
-		this.path = path;
+		return new KeyBindingWithModifier[] {
-		return this;
-	}
-	
-	public KeyBinding[] getAllKeyBindings(){
-		return new KeyBinding[]{
 			keyToggleSprint,
 			keyToggleSneak,
 			keyToggleFlight,
 			keyToggleWalkForward,
 			keyToggleJump,
+			keyResetAllToggles,
 			keyOpenMenu
 		};
 	}
 	
-	public void save(){
+	public void save() {
-		ConfigSerializer.serialize(path, this);
+		ConfigSerializer.write(path, this);
 	}
 }

src/main/java/chylex/bettercontrols/config/ConfigSerializer.java

@@ -1,4 +1,6 @@
 package chylex.bettercontrols.config;
+
+import chylex.bettercontrols.input.SprintMode;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonDeserializationContext;
@@ -10,7 +12,7 @@ import com.google.gson.JsonSerializationContext;
 import com.google.gson.JsonSerializer;
 import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonWriter;
-import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.Mth;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import java.io.FileNotFoundException;
@@ -21,78 +23,139 @@ import java.nio.file.Files;
 import java.nio.file.NoSuchFileException;
 import java.nio.file.Path;
 
-final class ConfigSerializer implements JsonSerializer<BetterControlsConfig>, JsonDeserializer<BetterControlsConfig>{
+final class ConfigSerializer implements JsonSerializer<BetterControlsConfig>, JsonDeserializer<BetterControlsConfig> {
 	private static final Logger logger = LogManager.getLogger();
 	private static final Gson gson = new GsonBuilder().registerTypeAdapter(BetterControlsConfig.class, new ConfigSerializer()).setPrettyPrinting().create();
 	
-	private ConfigSerializer(){}
+	private ConfigSerializer() {}
 	
 	@Override
-	public JsonElement serialize(final BetterControlsConfig cfg, final Type typeOfSrc, final JsonSerializationContext context){
+	public JsonElement serialize(BetterControlsConfig cfg, Type typeOfSrc, JsonSerializationContext context) {
-		final JsonObject obj = new JsonObject();
+		JsonObject obj = new JsonObject();
 		
 		Json.writeKeyBinding(obj, "Sprint.KeyToggle", cfg.keyToggleSprint);
+		Json.setEnum(obj, "Sprint.Mode", cfg.sprintMode);
 		Json.setBool(obj, "Sprint.DoubleTapForward", cfg.doubleTapForwardToSprint);
-		Json.setBool(obj, "Sprint.TapToStop", cfg.tapSprintKeyAgainToStopSprinting);
 		Json.setBool(obj, "Sprint.ResumeAfterHittingObstacle", cfg.resumeSprintingAfterHittingObstacle);
 		
 		Json.writeKeyBinding(obj, "Sneak.KeyToggle", cfg.keyToggleSneak);
 		Json.setBool(obj, "Sneak.SmoothCamera", cfg.sneakingMovesCameraSmoothly);
 		
+		Json.writeKeyBinding(obj, "Glide.KeyStart", cfg.keyStartGlide);
+		Json.setBool(obj, "Glide.DoubleTapJump", cfg.doubleTapJumpToGlide);
+		
 		Json.writeKeyBinding(obj, "Flight.KeyToggle.Creative", cfg.keyToggleFlight);
+		Json.setBool(obj, "Flight.DoubleTapJump", cfg.doubleTapJumpToToggleFlight);
+		Json.setFloat(obj, "Flight.InertiaMultiplier", cfg.flightInertiaMultiplier);
+		Json.setBool(obj, "Flight.DisableChangingFOV", cfg.disableChangingFovWhileFlying);
 		Json.setBool(obj, "Flight.FlyOnGround.Creative", cfg.flyOnGroundInCreative);
-		Json.setFloat(obj, "Flight.SpeedMp.Creative.Default", cfg.flightSpeedMpCreativeDefault);
+		Json.setFloat(obj, "Flight.SpeedMp.Creative.Default", cfg.flightHorizontalSpeedMpCreativeDefault);
-		Json.setFloat(obj, "Flight.SpeedMp.Creative.Sprinting", cfg.flightSpeedMpCreativeSprinting);
+		Json.setFloat(obj, "Flight.SpeedMp.Creative.Sprinting", cfg.flightHorizontalSpeedMpCreativeSprinting);
-		Json.setFloat(obj, "Flight.SpeedMp.Spectator.Default", cfg.flightSpeedMpSpectatorDefault);
+		Json.setFloat(obj, "Flight.SpeedMp.Spectator.Default", cfg.flightHorizontalSpeedMpSpectatorDefault);
-		Json.setFloat(obj, "Flight.SpeedMp.Spectator.Sprinting", cfg.flightSpeedMpSpectatorSprinting);
+		Json.setFloat(obj, "Flight.SpeedMp.Spectator.Sprinting", cfg.flightHorizontalSpeedMpSpectatorSprinting);
+		Json.setFloat(obj, "Flight.VerticalSpeedMp.Creative.Default", cfg.flightVerticalSpeedMpCreativeDefault);
+		Json.setFloat(obj, "Flight.VerticalSpeedMp.Creative.Sprinting", cfg.flightVerticalSpeedMpCreativeSprinting);
+		Json.setFloat(obj, "Flight.VerticalSpeedMp.Spectator.Default", cfg.flightVerticalSpeedMpSpectatorDefault);
+		Json.setFloat(obj, "Flight.VerticalSpeedMp.Spectator.Sprinting", cfg.flightVerticalSpeedMpSpectatorSprinting);
 		
 		Json.writeKeyBinding(obj, "Misc.KeyToggleWalkForward", cfg.keyToggleWalkForward);
 		Json.writeKeyBinding(obj, "Misc.KeyToggleJump", cfg.keyToggleJump);
+		Json.writeKeyBinding(obj, "Misc.KeyResetAllToggles", cfg.keyResetAllToggles);
 		Json.writeKeyBinding(obj, "Misc.KeyOpenMenu", cfg.keyOpenMenu);
 		
 		return obj;
 	}
 	
 	@Override
-	public BetterControlsConfig deserialize(final JsonElement json, final Type typeOfT, final JsonDeserializationContext context) throws JsonParseException{
+	public BetterControlsConfig deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
-		final BetterControlsConfig cfg = new BetterControlsConfig();
+		BetterControlsConfig cfg = new BetterControlsConfig();
-		final JsonObject obj = json.getAsJsonObject();
+		JsonObject obj = json.getAsJsonObject();
+		
+		if (obj.has("Sprint.TapToStop") && obj.get("Sprint.TapToStop").getAsBoolean()) {
+			cfg.sprintMode = SprintMode.TAP_TO_TOGGLE;
+		}
+		
+		if (obj.has("Flight.DisableInertia") && obj.get("Flight.DisableInertia").getAsBoolean()) {
+			cfg.flightInertiaMultiplier = 0F;
+		}
 		
 		Json.readKeyBinding(obj, "Sprint.KeyToggle", cfg.keyToggleSprint);
+		cfg.sprintMode = Json.getEnum(obj, "Sprint.Mode", cfg.sprintMode, SprintMode.class);
 		cfg.doubleTapForwardToSprint = Json.getBool(obj, "Sprint.DoubleTapForward", cfg.doubleTapForwardToSprint);
-		cfg.tapSprintKeyAgainToStopSprinting = Json.getBool(obj, "Sprint.TapToStop", cfg.tapSprintKeyAgainToStopSprinting);
 		cfg.resumeSprintingAfterHittingObstacle = Json.getBool(obj, "Sprint.ResumeAfterHittingObstacle", cfg.resumeSprintingAfterHittingObstacle);
 		
 		Json.readKeyBinding(obj, "Sneak.KeyToggle", cfg.keyToggleSneak);
 		cfg.sneakingMovesCameraSmoothly = Json.getBool(obj, "Sneak.SmoothCamera", cfg.sneakingMovesCameraSmoothly);
 		
+		Json.readKeyBinding(obj, "Glide.KeyStart", cfg.keyStartGlide);
+		cfg.doubleTapJumpToGlide = Json.getBool(obj, "Glide.DoubleTapJump", cfg.doubleTapJumpToGlide);
+		
 		Json.readKeyBinding(obj, "Flight.KeyToggle.Creative", cfg.keyToggleFlight);
+		cfg.doubleTapJumpToToggleFlight = Json.getBool(obj, "Flight.DoubleTapJump", cfg.doubleTapJumpToToggleFlight);
+		cfg.flightInertiaMultiplier = Json.getFloat(obj, "Flight.InertiaMultiplier", cfg.flightInertiaMultiplier, 0F, 1F);
+		cfg.disableChangingFovWhileFlying = Json.getBool(obj, "Flight.DisableChangingFOV", cfg.disableChangingFovWhileFlying);
 		cfg.flyOnGroundInCreative = Json.getBool(obj, "Flight.FlyOnGround.Creative", cfg.flyOnGroundInCreative);
-		cfg.flightSpeedMpCreativeDefault = MathHelper.clamp(Json.getFloat(obj, "Flight.SpeedMp.Creative.Default", cfg.flightSpeedMpCreativeDefault), 0.25F, 8F);
+		cfg.flightHorizontalSpeedMpCreativeDefault = readHorizontalSpeedMultiplier(obj, "Flight.SpeedMp.Creative.Default", cfg.flightHorizontalSpeedMpCreativeDefault);
-		cfg.flightSpeedMpCreativeSprinting = MathHelper.clamp(Json.getFloat(obj, "Flight.SpeedMp.Creative.Sprinting", cfg.flightSpeedMpCreativeSprinting), 0.25F, 8F);
+		cfg.flightHorizontalSpeedMpCreativeSprinting = readHorizontalSpeedMultiplier(obj, "Flight.SpeedMp.Creative.Sprinting", cfg.flightHorizontalSpeedMpCreativeSprinting);
-		cfg.flightSpeedMpSpectatorDefault = MathHelper.clamp(Json.getFloat(obj, "Flight.SpeedMp.Spectator.Default", cfg.flightSpeedMpSpectatorDefault), 0.25F, 8F);
+		cfg.flightHorizontalSpeedMpSpectatorDefault = readHorizontalSpeedMultiplier(obj, "Flight.SpeedMp.Spectator.Default", cfg.flightHorizontalSpeedMpSpectatorDefault);
-		cfg.flightSpeedMpSpectatorSprinting = MathHelper.clamp(Json.getFloat(obj, "Flight.SpeedMp.Spectator.Sprinting", cfg.flightSpeedMpSpectatorSprinting), 0.25F, 8F);
+		cfg.flightHorizontalSpeedMpSpectatorSprinting = readHorizontalSpeedMultiplier(obj, "Flight.SpeedMp.Spectator.Sprinting", cfg.flightHorizontalSpeedMpSpectatorSprinting);
+		cfg.flightVerticalSpeedMpCreativeDefault = readVerticalSpeedMultiplier(obj, cfg, "Flight.VerticalSpeedMp.Creative.Default", "Flight.VerticalBoost.Creative.Default", cfg.flightVerticalSpeedMpCreativeDefault);
+		cfg.flightVerticalSpeedMpCreativeSprinting = readVerticalSpeedMultiplier(obj, cfg, "Flight.VerticalSpeedMp.Creative.Sprinting", "Flight.VerticalBoost.Creative.Sprinting", cfg.flightVerticalSpeedMpCreativeSprinting);
+		cfg.flightVerticalSpeedMpSpectatorDefault = readVerticalSpeedMultiplier(obj, cfg, "Flight.VerticalSpeedMp.Spectator.Default", "Flight.VerticalBoost.Spectator.Default", cfg.flightVerticalSpeedMpSpectatorDefault);
+		cfg.flightVerticalSpeedMpSpectatorSprinting = readVerticalSpeedMultiplier(obj, cfg, "Flight.VerticalSpeedMp.Spectator.Sprinting", "Flight.VerticalBoost.Spectator.Sprinting", cfg.flightVerticalSpeedMpSpectatorSprinting);
 		
 		Json.readKeyBinding(obj, "Misc.KeyToggleWalkForward", cfg.keyToggleWalkForward);
 		Json.readKeyBinding(obj, "Misc.KeyToggleJump", cfg.keyToggleJump);
+		Json.readKeyBinding(obj, "Misc.KeyResetAllToggles", cfg.keyResetAllToggles);
 		Json.readKeyBinding(obj, "Misc.KeyOpenMenu", cfg.keyOpenMenu);
 		
 		return cfg;
 	}
 	
-	static void serialize(final Path path, final BetterControlsConfig config){
+	private static float readHorizontalSpeedMultiplier(JsonObject obj, String key, float defaultValue) {
-		try(final JsonWriter writer = gson.newJsonWriter(Files.newBufferedWriter(path, StandardCharsets.UTF_8))){
+		return Json.getFloat(obj, key, defaultValue, 0.25F, 8F);
+	}
+	
+	private static float readVerticalSpeedMultiplier(JsonObject obj, BetterControlsConfig cfg, String newKey, String legacyBoostKey, float defaultValue) {
+		if (obj.has(newKey)) {
+			return Json.getFloat(obj, newKey, defaultValue, 0.25F, 8F);
+		}
+		else if (obj.has(legacyBoostKey)) {
+			cfg.wasMigrated = true;
+			
+			float value = 1F + Json.getFloat(obj, legacyBoostKey, 0F, 0F, 3F);
+			// 1.25x, 1.75x, 2.5x, and 3.5x are not supported
+			if (Mth.equal(value, 1.25F) || Mth.equal(value, 1.75F)) {
+				return 1.5F;
+			}
+			else if (Mth.equal(value, 2.5F)) {
+				return 2F;
+			}
+			else if (Mth.equal(value, 3.5F)) {
+				return 3F;
+			}
+			else {
+				return value;
+			}
+		}
+		else {
+			return defaultValue;
+		}
+	}
+	
+	static void write(Path path, BetterControlsConfig config) {
+		try (JsonWriter writer = gson.newJsonWriter(Files.newBufferedWriter(path, StandardCharsets.UTF_8))) {
 			gson.getAdapter(BetterControlsConfig.class).write(writer, config);
-		}catch(final IOException e){
+		} catch (IOException e) {
 			logger.error("Error saving BetterControls configuration file!", e);
 		}
 	}
 	
-	static BetterControlsConfig deserialize(final Path path){
+	static BetterControlsConfig read(Path path) {
-		try(final JsonReader jsonReader = new JsonReader(Files.newBufferedReader(path, StandardCharsets.UTF_8))){
+		try (JsonReader jsonReader = new JsonReader(Files.newBufferedReader(path, StandardCharsets.UTF_8))) {
 			return gson.getAdapter(BetterControlsConfig.class).read(jsonReader);
-		}catch(final FileNotFoundException | NoSuchFileException ignored){
+		} catch (FileNotFoundException | NoSuchFileException ignored) {
-		}catch(final IOException e){
+		} catch (IOException e) {
 			logger.error("Error reading BetterControls configuration file!", e);
 		}
 		

src/main/java/chylex/bettercontrols/config/Json.java

@@ -1,53 +1,77 @@
 package chylex.bettercontrols.config;
+
 import chylex.bettercontrols.input.KeyBindingWithModifier;
 import chylex.bettercontrols.input.ModifierKey;
 import com.google.gson.JsonObject;
-import net.minecraft.client.util.InputUtil;
+import com.mojang.blaze3d.platform.InputConstants;
 
-final class Json{
+final class Json {
-	private Json(){}
+	private Json() {}
 	
-	static void setInt(final JsonObject obj, final String key, final int value){
+	static void setFloat(JsonObject obj, String key, float value) {
-		obj.addProperty(key, Integer.valueOf(value));
-	}
-	
-	static int getInt(final JsonObject obj, final String key, final int defaultValue){
-		return obj.has(key) ? obj.get(key).getAsInt() : defaultValue;
-	}
-	
-	static void setFloat(final JsonObject obj, final String key, final float value){
 		obj.addProperty(key, Float.valueOf(value));
 	}
 	
-	static float getFloat(final JsonObject obj, final String key, final float defaultValue){
+	static float getFloat(JsonObject obj, String key, float defaultValue, float minValue, float maxValue) {
-		return obj.has(key) ? obj.get(key).getAsFloat() : defaultValue;
+		float value = obj.has(key) ? obj.get(key).getAsFloat() : defaultValue;
+		return Math.max(minValue, Math.min(maxValue, value));
 	}
 	
-	static void setBool(final JsonObject obj, final String key, final boolean value){
+	static void setBool(JsonObject obj, String key, boolean value) {
 		obj.addProperty(key, Boolean.valueOf(value));
 	}
 	
-	static boolean getBool(final JsonObject obj, final String key, final boolean defaultValue){
+	static boolean getBool(JsonObject obj, String key, boolean defaultValue) {
 		return obj.has(key) ? obj.get(key).getAsBoolean() : defaultValue;
 	}
 	
+	@SuppressWarnings("SameParameterValue")
+	static <T extends Enum<T>> void setEnum(JsonObject obj, String key, T value) {
+		obj.addProperty(key, value.name());
+	}
+	
+	@SuppressWarnings("SameParameterValue")
+	static <T extends Enum<T>> T getEnum(JsonObject obj, String key, T defaultValue, Class<T> enumClass) {
+		if (!obj.has(key)) {
+			return defaultValue;
+		}
+		
+		T[] constants = enumClass.getEnumConstants();
+		
+		if (constants != null) {
+			String value = obj.get(key).getAsString();
+			
+			for (T constant : constants) {
+				if (constant.name().equalsIgnoreCase(value)) {
+					return constant;
+				}
+			}
+		}
+		
+		return defaultValue;
+	}
+	
 	private static final String KEY_SUFFIX = ".Key";
 	private static final String MOD_SUFFIX = ".Mod";
 	
-	static void writeKeyBinding(final JsonObject obj, final String key, final KeyBindingWithModifier keyBinding){
+	static void writeKeyBinding(JsonObject obj, String key, KeyBindingWithModifier keyBinding) {
-		obj.addProperty(key + KEY_SUFFIX, keyBinding.getBoundKeyTranslationKey());
+		obj.addProperty(key + KEY_SUFFIX, keyBinding.saveString());
 		
-		if (keyBinding.getModifier() != null){
+		if (keyBinding.getModifier() != null) {
 			obj.addProperty(key + MOD_SUFFIX, Integer.valueOf(keyBinding.getModifier().id));
 		}
 	}
 	
-	static void readKeyBinding(final JsonObject obj, final String key, final KeyBindingWithModifier keyBinding){
+	static void readKeyBinding(JsonObject obj, String key, KeyBindingWithModifier keyBinding) {
-		if (obj.has(key + KEY_SUFFIX)){
+		if (obj.has(key + KEY_SUFFIX)) {
-			keyBinding.setBoundKey(InputUtil.fromTranslationKey(obj.get(key + KEY_SUFFIX).getAsString()));
+			try {
+				keyBinding.setKey(InputConstants.getKey(obj.get(key + KEY_SUFFIX).getAsString()));
+			} catch (IllegalArgumentException e) {
+				e.printStackTrace(); // let's not crash if the config file has garbage, okay?
+			}
 		}
 		
-		if (obj.has(key + MOD_SUFFIX)){
+		if (obj.has(key + MOD_SUFFIX)) {
 			keyBinding.setModifier(ModifierKey.getById(obj.get(key + MOD_SUFFIX).getAsInt()));
 		}
 	}

src/main/java/chylex/bettercontrols/gui/BetterControlsScreen.java

@@ -1,161 +1,200 @@
 package chylex.bettercontrols.gui;
-import chylex.bettercontrols.BetterControlsMod;
+
+import chylex.bettercontrols.BetterControlsCommon;
 import chylex.bettercontrols.config.BetterControlsConfig;
-import chylex.bettercontrols.gui.elements.BooleanValueWidget;
-import chylex.bettercontrols.gui.elements.CycleButtonWidget;
 import chylex.bettercontrols.gui.elements.DiscreteValueSliderWidget;
 import chylex.bettercontrols.gui.elements.KeyBindingWidget;
 import chylex.bettercontrols.gui.elements.Option;
 import chylex.bettercontrols.gui.elements.TextWidget;
 import chylex.bettercontrols.input.KeyBindingWithModifier;
 import chylex.bettercontrols.input.ModifierKey;
-import net.minecraft.client.MinecraftClient;
+import chylex.bettercontrols.input.SprintMode;
-import net.minecraft.client.gui.Element;
+import com.google.common.collect.ImmutableList;
-import net.minecraft.client.gui.screen.Screen;
+import com.mojang.blaze3d.platform.InputConstants;
-import net.minecraft.client.gui.screen.ScreenTexts;
+import it.unimi.dsi.fastutil.booleans.BooleanConsumer;
-import net.minecraft.client.gui.screen.options.GameOptionsScreen;
+import net.minecraft.client.KeyMapping;
-import net.minecraft.client.gui.widget.ButtonWidget;
+import net.minecraft.client.Minecraft;
-import net.minecraft.client.options.KeyBinding;
+import net.minecraft.client.gui.components.CycleButton;
-import net.minecraft.client.util.InputUtil;
+import net.minecraft.client.gui.components.events.GuiEventListener;
-import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.gui.screens.Screen;
-import net.minecraft.text.LiteralText;
+import net.minecraft.client.gui.screens.options.OptionsSubScreen;
-import net.minecraft.text.Text;
+import net.minecraft.network.chat.Component;
+import org.jetbrains.annotations.Nullable;
 import org.lwjgl.glfw.GLFW;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.function.Consumer;
 import static chylex.bettercontrols.gui.OptionListWidget.COL2_W;
 import static chylex.bettercontrols.gui.OptionListWidget.COL4_W;
 import static chylex.bettercontrols.gui.OptionListWidget.ROW_WIDTH;
 import static chylex.bettercontrols.gui.OptionListWidget.col2;
 import static chylex.bettercontrols.gui.OptionListWidget.col4;
 import static chylex.bettercontrols.gui.elements.TextWidget.CENTER;
+import static net.minecraft.network.chat.Component.literal;
 
-public class BetterControlsScreen extends GameOptionsScreen{
+public class BetterControlsScreen extends OptionsSubScreen {
-	public static final LiteralText TITLE = new LiteralText("Better Controls");
+	private static Component text(String text) {
+		return literal(text);
+	}
+	
+	public static final Component TITLE = text("Better Controls");
 	
 	private static final int BOTTOM_PADDING = 3;
 	private static final int TEXT_PADDING_RIGHT = 4;
 	private static final int TITLE_MARGIN_TOP = 3;
 	private static final int ROW_HEIGHT = 22;
 	
+	private final List<Option<SprintMode>> SPRINT_MODE_OPTIONS = Arrays.asList(
+		new Option<>(SprintMode.TAP_TO_START, text("Tap To Start Sprinting")),
+		new Option<>(SprintMode.TAP_TO_TOGGLE, text("Tap To Start / Stop Sprinting")),
+		new Option<>(SprintMode.HOLD, text("Hold To Sprint"))
+	);
+	
 	// Options
 	
-	private int generateSprintingOptions(int y, final List<Element> elements){
+	private int generateSprintingOptions(int y, List<GuiEventListener> elements) {
-		final BetterControlsConfig cfg = BetterControlsMod.config;
+		BetterControlsConfig cfg = BetterControlsCommon.getConfig();
-		
-		generateKeyBindingWithModifierOption(y, elements, Text.of("Toggle Sprint"), cfg.keyToggleSprint);
 		
+		generateKeyBindingWithModifierRow(y, elements, text("Toggle Sprint"), cfg.keyToggleSprint);
 		y += ROW_HEIGHT;
 		
-		generateLeftSideText(y, elements, Text.of("Double Tap 'Walk Forwards' To Sprint"));
+		generateCycleOptionRow(y, elements, text("Sprint Key Mode"), SPRINT_MODE_OPTIONS, cfg.sprintMode, value -> cfg.sprintMode = value);
-		elements.add(new BooleanValueWidget(col2(1), y, COL2_W, cfg.doubleTapForwardToSprint, value -> cfg.doubleTapForwardToSprint = value));
-		
 		y += ROW_HEIGHT;
 		
-		generateLeftSideText(y, elements, Text.of("Tap 'Sprint' While Sprinting To Stop"));
+		generateBooleanOptionRow(y, elements, text("Double Tap 'Walk Forwards' To Sprint"), cfg.doubleTapForwardToSprint, value -> cfg.doubleTapForwardToSprint = value);
-		elements.add(new BooleanValueWidget(col2(1), y, COL2_W, cfg.tapSprintKeyAgainToStopSprinting, value -> cfg.tapSprintKeyAgainToStopSprinting = value));
-		
 		y += ROW_HEIGHT;
 		
-		generateLeftSideText(y, elements, Text.of("Resume Sprinting After Hitting Obstacle"));
+		generateBooleanOptionRow(y, elements, text("Resume Sprinting After Hitting Obstacle"), cfg.resumeSprintingAfterHittingObstacle, value -> cfg.resumeSprintingAfterHittingObstacle = value);
-		elements.add(new BooleanValueWidget(col2(1), y, COL2_W, cfg.resumeSprintingAfterHittingObstacle, value -> cfg.resumeSprintingAfterHittingObstacle = value));
-		
 		y += ROW_HEIGHT;
+		
 		return y;
 	}
 	
-	private int generateSneakingOptions(int y, final List<Element> elements){
+	private int generateSneakingOptions(int y, List<GuiEventListener> elements) {
-		final BetterControlsConfig cfg = BetterControlsMod.config;
+		BetterControlsConfig cfg = BetterControlsCommon.getConfig();
-		
-		generateKeyBindingWithModifierOption(y, elements, Text.of("Toggle Sneak"), cfg.keyToggleSneak);
 		
+		generateKeyBindingWithModifierRow(y, elements, text("Toggle Sneak"), cfg.keyToggleSneak);
 		y += ROW_HEIGHT;
 		
-		generateLeftSideText(y, elements, Text.of("Move Camera Smoothly"));
+		generateBooleanOptionRow(y, elements, text("Move Camera Smoothly"), cfg.sneakingMovesCameraSmoothly, value -> cfg.sneakingMovesCameraSmoothly = value);
-		elements.add(new BooleanValueWidget(col2(1), y, COL2_W, cfg.sneakingMovesCameraSmoothly, value -> cfg.sneakingMovesCameraSmoothly = value));
-		
 		y += ROW_HEIGHT;
+		
 		return y;
 	}
 	
-	@SuppressWarnings({ "AutoBoxing", "AutoUnboxing" })
+	private int generateGlidingOptions(int y, List<GuiEventListener> elements) {
-	private int generateFlightOptions(int y, final List<Element> elements){
+		BetterControlsConfig cfg = BetterControlsCommon.getConfig();
-		final BetterControlsConfig cfg = BetterControlsMod.config;
 		
-		final List<Option<Float>> flightSpeedOptions = Arrays.asList(
+		generateKeyBindingWithModifierRow(y, elements, text("Start a Glide"), cfg.keyStartGlide);
-			new Option<>(Float.valueOf(0.25F), Text.of("0.25x")),
+		y += ROW_HEIGHT;
-			new Option<>(Float.valueOf(0.50F), Text.of("0.5x")),
+		
-			new Option<>(Float.valueOf(0.75F), Text.of("0.75x")),
+		generateBooleanOptionRow(y, elements, text("Double Tap 'Jump' To Start a Glide"), cfg.doubleTapJumpToGlide, value -> cfg.doubleTapJumpToGlide = value);
-			new Option<>(Float.valueOf(1.00F), Text.of("1x")),
+		y += ROW_HEIGHT;
-			new Option<>(Float.valueOf(1.50F), Text.of("1.5x")),
+		
-			new Option<>(Float.valueOf(2.00F), Text.of("2x")),
+		return y;
-			new Option<>(Float.valueOf(3.00F), Text.of("3x")),
+	}
-			new Option<>(Float.valueOf(4.00F), Text.of("4x")),
+	
-			new Option<>(Float.valueOf(6.00F), Text.of("6x")),
+	private int generateFlightOptions(int y, List<GuiEventListener> elements) {
-			new Option<>(Float.valueOf(8.00F), Text.of("8x"))
+		BetterControlsConfig cfg = BetterControlsCommon.getConfig();
+		
+		ImmutableList<Option<Float>> flightInertiaOptions = ImmutableList.of(
+			new Option<>(Float.valueOf(0.00F), text("0x")),
+			new Option<>(Float.valueOf(0.25F), text("0.25x")),
+			new Option<>(Float.valueOf(0.50F), text("0.5x")),
+			new Option<>(Float.valueOf(0.75F), text("0.75x")),
+			new Option<>(Float.valueOf(1.00F), text("1x"))
 		);
 		
-		generateKeyBindingWithModifierOption(y, elements, Text.of("Toggle Flight (Creative)"), cfg.keyToggleFlight);
+		ImmutableList<Option<Float>> flightSpeedOptions = ImmutableList.of(
+			new Option<>(Float.valueOf(0.25F), text("0.25x")),
+			new Option<>(Float.valueOf(0.50F), text("0.5x")),
+			new Option<>(Float.valueOf(0.75F), text("0.75x")),
+			new Option<>(Float.valueOf(1.00F), text("1x")),
+			new Option<>(Float.valueOf(1.50F), text("1.5x")),
+			new Option<>(Float.valueOf(2.00F), text("2x")),
+			new Option<>(Float.valueOf(3.00F), text("3x")),
+			new Option<>(Float.valueOf(4.00F), text("4x")),
+			new Option<>(Float.valueOf(5.00F), text("5x")),
+			new Option<>(Float.valueOf(6.00F), text("6x")),
+			new Option<>(Float.valueOf(7.00F), text("7x")),
+			new Option<>(Float.valueOf(8.00F), text("8x"))
+		);
 		
+		generateKeyBindingWithModifierRow(y, elements, text("Toggle Flight (Creative)"), cfg.keyToggleFlight);
 		y += ROW_HEIGHT;
 		
-		generateLeftSideText(y, elements, Text.of("Fly On Ground (Creative Mode)"));
+		generateBooleanOptionRow(y, elements, text("Double Tap 'Jump' To Fly (Creative)"), cfg.doubleTapJumpToToggleFlight, value -> cfg.doubleTapJumpToToggleFlight = value);
-		elements.add(new BooleanValueWidget(col2(1), y, COL2_W, cfg.flyOnGroundInCreative, value -> cfg.flyOnGroundInCreative = value));
-		
-		y += ROW_HEIGHT * 4 / 3;
-		
-		generateLeftSideText(y, elements, Text.of("Speed Multiplier (Creative)"));
-		elements.add(new DiscreteValueSliderWidget<>(col2(1), y, COL2_W, flightSpeedOptions, cfg.flightSpeedMpCreativeDefault, value -> cfg.flightSpeedMpCreativeDefault = value));
-		
 		y += ROW_HEIGHT;
 		
-		generateLeftSideText(y, elements, Text.of("Speed Multiplier (Creative + Sprinting)"));
+		generateLeftSideText(y, elements, text("Flight Inertia Multiplier"));
-		elements.add(new DiscreteValueSliderWidget<>(col2(1), y, COL2_W, flightSpeedOptions, cfg.flightSpeedMpCreativeSprinting, value -> cfg.flightSpeedMpCreativeSprinting = value));
+		elements.add(new DiscreteValueSliderWidget<>(col2(1), y, COL2_W, text("Flight Inertia Multiplier"), flightInertiaOptions, cfg.flightInertiaMultiplier, value -> cfg.flightInertiaMultiplier = value));
-		
 		y += ROW_HEIGHT;
 		
-		generateLeftSideText(y, elements, Text.of("Speed Multiplier (Spectator)"));
+		generateBooleanOptionRow(y, elements, text("Disable Field Of View Changing"), cfg.disableChangingFovWhileFlying, value -> cfg.disableChangingFovWhileFlying = value);
-		elements.add(new DiscreteValueSliderWidget<>(col2(1), y, COL2_W, flightSpeedOptions, cfg.flightSpeedMpSpectatorDefault, value -> cfg.flightSpeedMpSpectatorDefault = value));
-		
 		y += ROW_HEIGHT;
 		
-		generateLeftSideText(y, elements, Text.of("Speed Multiplier (Spectator + Sprinting)"));
+		generateBooleanOptionRow(y, elements, text("Fly On Ground (Creative)"), cfg.flyOnGroundInCreative, value -> cfg.flyOnGroundInCreative = value);
-		elements.add(new DiscreteValueSliderWidget<>(col2(1), y, COL2_W, flightSpeedOptions, cfg.flightSpeedMpSpectatorSprinting, value -> cfg.flightSpeedMpSpectatorSprinting = value));
-		
 		y += ROW_HEIGHT;
+		
+		y += ROW_HEIGHT / 3;
+		elements.add(new TextWidget(col4(2), y, COL4_W - TEXT_PADDING_RIGHT, text("Creative"), CENTER));
+		elements.add(new TextWidget(col4(3), y, COL4_W - TEXT_PADDING_RIGHT, text("Spectator"), CENTER));
+		y += ROW_HEIGHT * 7 / 8;
+		
+		generateLeftSideText(y, elements, text("Horizontal Speed Multiplier (Default)"));
+		elements.add(new DiscreteValueSliderWidget<>(col4(2), y, COL4_W, text("Horizontal Speed Multiplier in Creative Mode"), flightSpeedOptions, cfg.flightHorizontalSpeedMpCreativeDefault, value -> cfg.flightHorizontalSpeedMpCreativeDefault = value));
+		elements.add(new DiscreteValueSliderWidget<>(col4(3), y, COL4_W, text("Horizontal Speed Multiplier in Spectator Mode"), flightSpeedOptions, cfg.flightHorizontalSpeedMpSpectatorDefault, value -> cfg.flightHorizontalSpeedMpSpectatorDefault = value));
+		y += ROW_HEIGHT;
+		
+		generateLeftSideText(y, elements, text("Horizontal Speed Multiplier (Sprinting)"));
+		elements.add(new DiscreteValueSliderWidget<>(col4(2), y, COL4_W, text("Horizontal Speed Multiplier when Sprinting in Creative Mode"), flightSpeedOptions, cfg.flightHorizontalSpeedMpCreativeSprinting, value -> cfg.flightHorizontalSpeedMpCreativeSprinting = value));
+		elements.add(new DiscreteValueSliderWidget<>(col4(3), y, COL4_W, text("Horizontal Speed Multiplier when Sprinting in Spectator Mode"), flightSpeedOptions, cfg.flightHorizontalSpeedMpSpectatorSprinting, value -> cfg.flightHorizontalSpeedMpSpectatorSprinting = value));
+		y += ROW_HEIGHT;
+		
+		generateLeftSideText(y, elements, text("Vertical Speed Multiplier (Default)"));
+		elements.add(new DiscreteValueSliderWidget<>(col4(2), y, COL4_W, text("Vertical Speed Multiplier in Creative Mode"), flightSpeedOptions, cfg.flightVerticalSpeedMpCreativeDefault, value -> cfg.flightVerticalSpeedMpCreativeDefault = value));
+		elements.add(new DiscreteValueSliderWidget<>(col4(3), y, COL4_W, text("Vertical Speed Multiplier in Spectator Mode"), flightSpeedOptions, cfg.flightVerticalSpeedMpSpectatorDefault, value -> cfg.flightVerticalSpeedMpSpectatorDefault = value));
+		y += ROW_HEIGHT;
+		
+		generateLeftSideText(y, elements, text("Vertical Speed Multiplier (Sprinting)"));
+		elements.add(new DiscreteValueSliderWidget<>(col4(2), y, COL4_W, text("Vertical Speed Multiplier when Sprinting in Creative Mode"), flightSpeedOptions, cfg.flightVerticalSpeedMpCreativeSprinting, value -> cfg.flightVerticalSpeedMpCreativeSprinting = value));
+		elements.add(new DiscreteValueSliderWidget<>(col4(3), y, COL4_W, text("Vertical Speed Multiplier when Sprinting in Spectator Mode"), flightSpeedOptions, cfg.flightVerticalSpeedMpSpectatorSprinting, value -> cfg.flightVerticalSpeedMpSpectatorSprinting = value));
+		y += ROW_HEIGHT;
+		
 		return y;
 	}
 	
-	private int generateMiscellaneousOptions(int y, final List<Element> elements){
+	private int generateMiscellaneousOptions(int y, List<GuiEventListener> elements) {
-		final BetterControlsConfig cfg = BetterControlsMod.config;
+		BetterControlsConfig cfg = BetterControlsCommon.getConfig();
-		
-		generateKeyBindingWithModifierOption(y, elements, Text.of("Toggle Walk Forwards"), cfg.keyToggleWalkForward);
 		
+		generateKeyBindingWithModifierRow(y, elements, text("Toggle Walk Forwards"), cfg.keyToggleWalkForward);
 		y += ROW_HEIGHT;
 		
-		generateKeyBindingWithModifierOption(y, elements, Text.of("Toggle Jump"), cfg.keyToggleJump);
+		generateKeyBindingWithModifierRow(y, elements, text("Toggle Jump"), cfg.keyToggleJump);
+		y += ROW_HEIGHT;
 		
+		generateKeyBindingWithModifierRow(y, elements, text("Reset All Toggles"), cfg.keyResetAllToggles);
 		y += ROW_HEIGHT * 4 / 3;
 		
-		generateKeyBindingWithModifierOption(y, elements, Text.of("Open Better Controls Menu"), cfg.keyOpenMenu);
+		generateKeyBindingWithModifierRow(y, elements, text("Open Better Controls Menu"), cfg.keyOpenMenu);
-		
 		y += ROW_HEIGHT;
+		
 		return y;
 	}
 	
 	// Helpers
 	
 	private static final List<Option<ModifierKey>> MODIFIER_OPTIONS = Arrays.asList(
-		new Option<>(null, Text.of("(No Modifier)")),
+		new Option<>(null, text("(No Modifier)")),
-		new Option<>(ModifierKey.CONTROL, Text.of("Control")),
+		new Option<>(ModifierKey.CONTROL, text("Control")),
-		new Option<>(ModifierKey.SHIFT, Text.of("Shift")),
+		new Option<>(ModifierKey.SHIFT, text("Shift")),
-		new Option<>(ModifierKey.ALT, Text.of("Alt"))
+		new Option<>(ModifierKey.ALT, text("Alt"))
 	);
 	
-	private void generateKeyBindingWithModifierOption(final int y, final List<Element> elements, final Text text, final KeyBindingWithModifier binding){
+	private void generateKeyBindingWithModifierRow(int y, List<GuiEventListener> elements, Component text, KeyBindingWithModifier binding) {
-		final CycleButtonWidget<ModifierKey> modifierButton = new CycleButtonWidget<>(col4(2), y, COL4_W, MODIFIER_OPTIONS, binding.getModifier(), binding::setModifier);
+		var modifierButton = Option.button(col4(2), y, COL4_W, text.plainCopy().append(" Modifier"), MODIFIER_OPTIONS, binding.getModifier(), binding::setModifier);
-		final KeyBindingWidget bindingButton = new KeyBindingWidget(col4(3), y, COL4_W, binding, this::startEditingKeyBinding);
+		var bindingButton = new KeyBindingWidget(col4(3), y, COL4_W, text, binding, this::startEditingKeyBinding);
 		bindingButton.linkButtonToBoundState(modifierButton);
 		
 		generateLeftSideText(y, elements, text);
@@ -164,7 +203,20 @@ public class BetterControlsScreen extends GameOptionsScreen{
 		allKeyBindings.add(bindingButton);
 	}
 	
-	private static void generateLeftSideText(final int y, final List<Element> elements, final Text text){
+	private static <T> void generateCycleOptionRow(int y, List<GuiEventListener> elements, Component text, List<Option<T>> options, T initialValue, Consumer<T> onValueChanged) {
+		generateLeftSideText(y, elements, text);
+		elements.add(Option.button(col2(1), y, COL2_W, text, options, initialValue, onValueChanged));
+	}
+	
+	private static void generateBooleanOptionRow(int y, List<GuiEventListener> elements, Component text, boolean initialValue, BooleanConsumer onValueChanged) {
+		generateLeftSideText(y, elements, text);
+		elements.add(CycleButton.onOffBuilder()
+			.displayOnlyValue()
+			.withInitialValue(Boolean.valueOf(initialValue))
+			.create(col2(1), y, COL2_W, 20, text, (btn, newValue) -> onValueChanged.accept(newValue.booleanValue())));
+	}
+	
+	private static void generateLeftSideText(int y, List<GuiEventListener> elements, Component text) {
 		elements.add(new TextWidget(col2(0), y, COL2_W - TEXT_PADDING_RIGHT, text));
 	}
 	
@@ -174,48 +226,55 @@ public class BetterControlsScreen extends GameOptionsScreen{
 	private KeyBindingWidget editingKeyBinding;
 	private final List<KeyBindingWidget> allKeyBindings = new ArrayList<>();
 	
-	public BetterControlsScreen(final Screen parentScreen){
+	@SuppressWarnings("DataFlowIssue")
-		super(parentScreen, MinecraftClient.getInstance().options, TITLE);
+	public BetterControlsScreen(@Nullable Screen parentScreen) {
+		super(parentScreen, Minecraft.getInstance().options, TITLE);
 	}
 	
 	@Override
-	public void init(){
+	protected void addContents() {
 		allKeyBindings.clear();
 		
-		final List<Element> elements = new ArrayList<>();
+		List<GuiEventListener> elements = new ArrayList<>();
 		int y = 0;
 		
-		elements.add(new TextWidget(0, y, ROW_WIDTH, ROW_HEIGHT, Text.of("Sprinting"), CENTER));
+		elements.add(new TextWidget(0, y, ROW_WIDTH, ROW_HEIGHT, text("Sprinting"), CENTER));
 		y = generateSprintingOptions(y + ROW_HEIGHT, elements) + TITLE_MARGIN_TOP;
 		
-		elements.add(new TextWidget(0, y, ROW_WIDTH, ROW_HEIGHT, Text.of("Sneaking"), CENTER));
+		elements.add(new TextWidget(0, y, ROW_WIDTH, ROW_HEIGHT, text("Sneaking"), CENTER));
 		y = generateSneakingOptions(y + ROW_HEIGHT, elements) + TITLE_MARGIN_TOP;
 		
-		elements.add(new TextWidget(0, y, ROW_WIDTH, ROW_HEIGHT, Text.of("Flying"), CENTER));
+		elements.add(new TextWidget(0, y, ROW_WIDTH, ROW_HEIGHT, text("Gliding"), CENTER));
+		y = generateGlidingOptions(y + ROW_HEIGHT, elements) + TITLE_MARGIN_TOP;
+		
+		elements.add(new TextWidget(0, y, ROW_WIDTH, ROW_HEIGHT, text("Flying"), CENTER));
 		y = generateFlightOptions(y + ROW_HEIGHT, elements) + TITLE_MARGIN_TOP;
 		
-		elements.add(new TextWidget(0, y, ROW_WIDTH, ROW_HEIGHT, Text.of("Miscellaneous"), CENTER));
+		elements.add(new TextWidget(0, y, ROW_WIDTH, ROW_HEIGHT, text("Miscellaneous"), CENTER));
 		y = generateMiscellaneousOptions(y + ROW_HEIGHT, elements) + TITLE_MARGIN_TOP;
 		
-		addButton(new ButtonWidget(width / 2 - 99, height - 29, 200, 20, ScreenTexts.DONE, btn -> client.openScreen(parent)));
+		optionsWidget = addRenderableWidget(new OptionListWidget(width, layout.getContentHeight(), layout.getHeaderHeight(), y - TITLE_MARGIN_TOP + BOTTOM_PADDING, elements));
-		addChild(optionsWidget = new OptionListWidget(21, height - 32, width, height, elements, y - TITLE_MARGIN_TOP + BOTTOM_PADDING));
 	}
 	
 	@Override
-	public void removed(){
+	protected void addOptions() {}
-		BetterControlsMod.config.save();
+	
+	@Override
+	protected void repositionElements() {
+		super.repositionElements();
+		
+		if (optionsWidget != null) {
+			optionsWidget.updateSize(width, layout);
+		}
 	}
 	
 	@Override
-	public void render(final MatrixStack matrices, final int mouseX, final int mouseY, final float delta){
+	public void removed() {
-		renderBackground(matrices);
+		BetterControlsCommon.getConfig().save();
-		optionsWidget.render(matrices, mouseX, mouseY, delta);
-		drawCenteredText(matrices, textRenderer, title, width / 2, 8, (255 << 16) | (255 << 8) | 255);
-		super.render(matrices, mouseX, mouseY, delta);
 	}
 	
-	private void startEditingKeyBinding(final KeyBindingWidget widget){
+	private void startEditingKeyBinding(KeyBindingWidget widget) {
-		if (editingKeyBinding != null){
+		if (editingKeyBinding != null) {
 			editingKeyBinding.stopEditing();
 		}
 		
@@ -223,40 +282,40 @@ public class BetterControlsScreen extends GameOptionsScreen{
 	}
 	
 	@Override
-	public boolean mouseClicked(final double mouseX, final double mouseY, final int button){
+	public boolean mouseClicked(double mouseX, double mouseY, int button) {
-		if (editingKeyBinding != null){
+		if (editingKeyBinding != null) {
-			editingKeyBinding.bindAndStopEditing(InputUtil.Type.MOUSE.createFromCode(button));
+			editingKeyBinding.bindAndStopEditing(InputConstants.Type.MOUSE.getOrCreate(button));
 			onKeyBindingEditingFinished();
 			return true;
 		}
-		else{
+		else {
 			return super.mouseClicked(mouseX, mouseY, button);
 		}
 	}
 	
 	@Override
-	public boolean keyPressed(final int keyCode, final int scanCode, final int modifiers){
+	public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
-		if (editingKeyBinding != null){
+		if (editingKeyBinding != null) {
-			if (keyCode == GLFW.GLFW_KEY_ESCAPE){
+			if (keyCode == GLFW.GLFW_KEY_ESCAPE) {
-				editingKeyBinding.bindAndStopEditing(InputUtil.UNKNOWN_KEY);
+				editingKeyBinding.bindAndStopEditing(InputConstants.UNKNOWN);
 			}
-			else{
+			else {
-				editingKeyBinding.bindAndStopEditing(InputUtil.fromKeyCode(keyCode, scanCode));
+				editingKeyBinding.bindAndStopEditing(InputConstants.getKey(keyCode, scanCode));
 			}
 			
 			onKeyBindingEditingFinished();
 			return true;
 		}
-		else{
+		else {
 			return super.keyPressed(keyCode, scanCode, modifiers);
 		}
 	}
 	
-	private void onKeyBindingEditingFinished(){
+	private void onKeyBindingEditingFinished() {
 		editingKeyBinding = null;
-		KeyBinding.updateKeysByCode();
+		KeyMapping.resetMapping();
 		
-		for(final KeyBindingWidget widget : allKeyBindings){
+		for (KeyBindingWidget widget : allKeyBindings) {
 			widget.updateKeyBindingText();
 		}
 	}

src/main/java/chylex/bettercontrols/gui/OptionListWidget.java

@@ -1,124 +1,146 @@
 package chylex.bettercontrols.gui;
+
 import chylex.bettercontrols.gui.OptionListWidget.Entry;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.Drawable;
+import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.client.gui.Element;
+import net.minecraft.client.gui.components.AbstractWidget;
-import net.minecraft.client.gui.widget.AbstractButtonWidget;
+import net.minecraft.client.gui.components.ContainerObjectSelectionList;
-import net.minecraft.client.gui.widget.ElementListWidget;
+import net.minecraft.client.gui.components.Renderable;
-import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.gui.components.events.GuiEventListener;
-import java.util.ArrayList;
+import net.minecraft.client.gui.narration.NarratableEntry;
-import java.util.Collections;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
-import java.util.stream.Collectors;
+import static java.util.stream.Collectors.toMap;
 
-public final class OptionListWidget extends ElementListWidget<Entry>{
+public final class OptionListWidget extends ContainerObjectSelectionList<Entry> {
 	public static final int ROW_WIDTH = 408;
-	public static final int ROW_PADDING = 2;
 	
-	public static final int COL2_W = (ROW_WIDTH / 2) - ROW_PADDING;
+	private static final int ROW_HORIZONTAL_PADDING = 2;
-	public static final int COL3_W = (ROW_WIDTH / 3) - ROW_PADDING;
+	private static final int SCROLL_MULTIPLIER = 18;
-	public static final int COL4_W = (ROW_WIDTH / 4) - ROW_PADDING;
-	public static final int COL6_W = (ROW_WIDTH / 6) - ROW_PADDING;
 	
-	public static int col2(final int column){
+	public static final int COL2_W = (ROW_WIDTH / 2) - ROW_HORIZONTAL_PADDING;
+	public static final int COL4_W = (ROW_WIDTH / 4) - ROW_HORIZONTAL_PADDING;
+	
+	public static int col2(int column) {
 		return (column * ROW_WIDTH) / 2;
 	}
 	
-	public static int col3(final int column){
+	public static int col4(int column) {
-		return (column * ROW_WIDTH) / 3;
-	}
-	
-	public static int col4(final int column){
 		return (column * ROW_WIDTH) / 4;
 	}
 	
-	public static int col6(final int column){
+	private static Offset getElementOffset(GuiEventListener element) {
-		return (column * ROW_WIDTH) / 6;
+		if (element instanceof OptionWidget widget) {
-	}
+			return new Offset(widget.getX(), widget.getY(), widget.getHeight());
-	
-	private static Offset getElementOffset(final Element element){
-		if (element instanceof Widget){
-			return new Offset(((Widget)element).getX(), ((Widget)element).getY());
 		}
-		else if (element instanceof AbstractButtonWidget){
+		else if (element instanceof AbstractWidget widget) {
-			return new Offset(((AbstractButtonWidget)element).x, ((AbstractButtonWidget)element).y);
+			return new Offset(widget.getX(), widget.getY(), widget.getHeight());
 		}
-		else{
+		else {
-			return new Offset(0, 0);
+			return new Offset(0, 0, 0);
 		}
 	}
 	
-	public interface Widget extends Element, Drawable{
+	public interface OptionWidget extends GuiEventListener, Renderable {
-		int getX();
-		int getY();
 		void setX(int x);
-		void setY(int y);
+		int getX();
-	}
-	
-	private static final class Offset{
-		public final int x;
-		public final int y;
 		
-		private Offset(final int x, final int y){
+		void setY(int y);
-			this.x = x;
+		int getY();
-			this.y = y;
+		
-		}
+		int getHeight();
 	}
 	
-	public OptionListWidget(final int top, final int bottom, final int width, final int height, final List<Element> widgets, final int innerHeight){
+	private record Offset(int x, int y, int height) {}
-		super(MinecraftClient.getInstance(), width, height, top, bottom, innerHeight);
+	
-		addEntry(new Entry(widgets));
+	@SuppressWarnings("ThisEscapedInObjectConstruction")
+	public OptionListWidget(int width, int height, int top, int innerHeight, List<GuiEventListener> widgets) {
+		super(Minecraft.getInstance(), width, height, top, innerHeight);
+		addEntry(new Entry(this, widgets));
 	}
 	
 	@Override
-	protected int getRowLeft(){
+	public int getRowLeft() {
-		return super.getRowLeft() - ROW_PADDING;
+		return super.getRowLeft() - ROW_HORIZONTAL_PADDING;
 	}
 	
 	@Override
-	public int getRowWidth(){
+	public int getRowWidth() {
 		return ROW_WIDTH;
 	}
 	
 	@Override
-	protected int getScrollbarPositionX(){
+	protected int scrollBarX() {
 		return (width + ROW_WIDTH) / 2 + 4;
 	}
 	
-	protected static final class Entry extends ElementListWidget.Entry<Entry>{
+	@Override
-		private final List<Element> elements;
+	public boolean mouseScrolled(double x, double y, double xAmount, double yAmount) {
-		private final Map<Element, Offset> offsets;
+		setScrollAmount(scrollAmount() - yAmount * SCROLL_MULTIPLIER);
+		return true;
+	}
+	
+	@Override
+	protected void ensureVisible(@NotNull Entry entry) {
+		// Scrolling to focused item is implemented in Entry.
+	}
+	
+	protected static final class Entry extends ContainerObjectSelectionList.Entry<Entry> {
+		private final OptionListWidget parentWidget;
+		private final List<GuiEventListener> elements;
+		private final List<NarratableEntry> narratables;
+		private final Map<GuiEventListener, Offset> offsets;
 		
-		public Entry(final List<Element> elements){
+		public Entry(OptionListWidget parentWidget, List<GuiEventListener> elements) {
-			this.elements = new ArrayList<>(elements);
+			this.parentWidget = parentWidget;
-			this.offsets = elements.stream().collect(Collectors.toMap(Function.identity(), OptionListWidget::getElementOffset));
+			this.elements = List.copyOf(elements);
+			this.narratables = elements.stream().filter(e -> e instanceof NarratableEntry).map(e -> (NarratableEntry)e).toList();
+			this.offsets = elements.stream().collect(toMap(Function.identity(), OptionListWidget::getElementOffset));
 		}
 		
 		@Override
-		public List<? extends Element> children(){
+		public void setFocused(@Nullable GuiEventListener element) {
-			return Collections.unmodifiableList(elements);
+			super.setFocused(element);
-		}
+			
-		
+			if (Minecraft.getInstance().getLastInputType().isKeyboard()) {
-		@Override
+				Offset offset = offsets.get(element);
-		public void render(final MatrixStack matrices, final int index, final int y, final int x, final int entryWidth, final int entryHeight, final int mouseX, final int mouseY, final boolean hovered, final float tickDelta){
+				if (offset != null) {
-			for(final Element element : elements){
+					parentWidget.setScrollAmount(offset.y + (offset.height * 0.5F) - (parentWidget.getHeight() * 0.5F) + 4);
-				final Offset offset = offsets.get(element);
-				
-				if (element instanceof AbstractButtonWidget){
-					final AbstractButtonWidget button = (AbstractButtonWidget)element;
-					button.x = x + offset.x;
-					button.y = y + offset.y;
 				}
-				else if (element instanceof Widget){
+			}
-					final Widget widget = (Widget)element;
+		}
+		
+		@NotNull
+		@Override
+		public List<? extends GuiEventListener> children() {
+			return elements;
+		}
+		
+		@NotNull
+		@Override
+		public List<? extends NarratableEntry> narratables() {
+			return narratables;
+		}
+		
+		@Override
+		public void render(@NotNull GuiGraphics graphics, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) {
+			for (GuiEventListener element : elements) {
+				Offset offset = offsets.get(element);
+				
+				if (element instanceof AbstractWidget widget) {
+					widget.setX(x + offset.x);
+					widget.setY(y + offset.y);
+				}
+				else if (element instanceof OptionWidget widget) {
 					widget.setX(x + offset.x);
 					widget.setY(y + offset.y);
 				}
 				
-				if (element instanceof Drawable){
+				if (element instanceof Renderable renderable) {
-					((Drawable)element).render(matrices, mouseX, mouseY, tickDelta);
+					renderable.render(graphics, mouseX, mouseY, tickDelta);
 				}
 			}
 		}

src/main/java/chylex/bettercontrols/gui/ScreenPatcher.java

@@ -1,57 +0,0 @@
-package chylex.bettercontrols.gui;
-import chylex.bettercontrols.mixin.AccessScreenButtons;
-import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.gui.Element;
-import net.minecraft.client.gui.screen.options.AccessibilityOptionsScreen;
-import net.minecraft.client.gui.screen.options.ControlsOptionsScreen;
-import net.minecraft.client.gui.widget.AbstractButtonWidget;
-import net.minecraft.client.gui.widget.ButtonListWidget;
-import net.minecraft.client.gui.widget.ButtonWidget;
-import net.minecraft.client.gui.widget.OptionButtonWidget;
-import net.minecraft.client.options.Option;
-import java.util.List;
-
-public final class ScreenPatcher{
-	private ScreenPatcher(){}
-	
-	public static void onControlsScreenOpened(final ControlsOptionsScreen screen){
-		final AccessScreenButtons accessor = (AccessScreenButtons)screen;
-		
-		final List<? extends Element> children = screen.children();
-		final List<AbstractButtonWidget> buttons = accessor.getButtons();
-		
-		final AbstractButtonWidget autoJump = buttons
-			.stream()
-			.filter(it -> it instanceof OptionButtonWidget && ((OptionButtonWidget)it).getOption() == Option.AUTO_JUMP)
-			.findAny()
-			.orElse(null);
-		
-		if (autoJump != null){
-			children.remove(autoJump);
-			buttons.remove(autoJump);
-			
-			accessor.callAddButton(new ButtonWidget(autoJump.x, autoJump.y, autoJump.getWidth(), autoJump.getHeight(), BetterControlsScreen.TITLE.copy().append("..."), btn -> {
-				MinecraftClient.getInstance().openScreen(new BetterControlsScreen(screen));
-			}));
-		}
-	}
-	
-	public static void onAccessibilityScreenOpened(final AccessibilityOptionsScreen screen){
-		final AccessScreenButtons accessor = (AccessScreenButtons)screen;
-		
-		screen.children()
-			.stream()
-			.filter(it -> it instanceof ButtonListWidget)
-			.flatMap(it -> ((ButtonListWidget)it).children().stream())
-			.flatMap(it -> it.children().stream())
-			.filter(it -> it instanceof OptionButtonWidget)
-			.forEach(it -> {
-				final OptionButtonWidget button = (OptionButtonWidget)it;
-				final Option option = button.getOption();
-				
-				if (option == Option.SPRINT_TOGGLED || option == Option.SNEAK_TOGGLED){
-					button.active = false;
-				}
-			});
-	}
-}

src/main/java/chylex/bettercontrols/gui/elements/BooleanValueWidget.java

@@ -1,27 +0,0 @@
-package chylex.bettercontrols.gui.elements;
-import it.unimi.dsi.fastutil.booleans.BooleanConsumer;
-import net.minecraft.client.gui.screen.ScreenTexts;
-import net.minecraft.client.gui.widget.ButtonWidget;
-
-public final class BooleanValueWidget extends ButtonWidget{
-	private final BooleanConsumer onChanged;
-	private boolean value;
-	
-	public BooleanValueWidget(final int x, final int y, final int width, final int height, final boolean currentValue, final BooleanConsumer onChanged){
-		super(x, y, width, height, currentValue ? ScreenTexts.ON : ScreenTexts.OFF, ignore -> {});
-		this.value = currentValue;
-		this.onChanged = onChanged;
-	}
-	
-	public BooleanValueWidget(final int x, final int y, final int width, final boolean currentValue, final BooleanConsumer onChanged){
-		this(x, y, width, 20, currentValue, onChanged);
-	}
-	
-	@Override
-	public void onPress(){
-		super.onPress();
-		value = !value;
-		setMessage(value ? ScreenTexts.ON : ScreenTexts.OFF);
-		onChanged.accept(value);
-	}
-}

src/main/java/chylex/bettercontrols/gui/elements/CycleButtonWidget.java

@@ -1,36 +0,0 @@
-package chylex.bettercontrols.gui.elements;
-import net.minecraft.client.gui.widget.ButtonWidget;
-import java.util.List;
-import java.util.function.Consumer;
-
-public class CycleButtonWidget<T> extends ButtonWidget{
-	private final List<Option<T>> options;
-	private final Consumer<T> onChanged;
-	private T selectedValue;
-	
-	public CycleButtonWidget(final int x, final int y, final int width, final int height, final List<Option<T>> options, final T selectedValue, final Consumer<T> onChanged){
-		super(x, y, width, height, Option.find(options, selectedValue).getText(), btn -> {});
-		this.options = options;
-		this.selectedValue = selectedValue;
-		this.onChanged = onChanged;
-	}
-	
-	public CycleButtonWidget(final int x, final int y, final int width, final List<Option<T>> options, final T selectedValue, final Consumer<T> onChanged){
-		this(x, y, width, 20, options, selectedValue, onChanged);
-	}
-	
-	@Override
-	public void onPress(){
-		int nextIndex = options.indexOf(Option.find(options, selectedValue)) + 1;
-		
-		if (nextIndex >= options.size()){
-			nextIndex = 0;
-		}
-		
-		final Option<T> newSelectedOption = options.get(nextIndex);
-		
-		selectedValue = newSelectedOption.getValue();
-		onChanged.accept(selectedValue);
-		setMessage(newSelectedOption.getText());
-	}
-}

src/main/java/chylex/bettercontrols/gui/elements/DiscreteValueSliderWidget.java

@@ -1,41 +1,86 @@
 package chylex.bettercontrols.gui.elements;
-import net.minecraft.client.gui.widget.SliderWidget;
+
-import net.minecraft.util.math.MathHelper;
+import com.google.common.collect.ImmutableList;
-import java.util.List;
+import net.minecraft.client.gui.components.AbstractSliderButton;
+import net.minecraft.client.gui.navigation.CommonInputs;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.util.Mth;
+import org.jetbrains.annotations.NotNull;
+import org.lwjgl.glfw.GLFW;
 import java.util.function.Consumer;
 
-public final class DiscreteValueSliderWidget<T> extends SliderWidget{
+public final class DiscreteValueSliderWidget<T> extends AbstractSliderButton {
-	private final List<Option<T>> options;
+	private final Component narration;
+	private final ImmutableList<Option<T>> options;
 	private final Consumer<T> onChanged;
 	private T selectedValue;
 	
-	public DiscreteValueSliderWidget(final int x, final int y, final int width, final int height, final List<Option<T>> options, final T selectedValue, final Consumer<T> onChanged){
+	public DiscreteValueSliderWidget(int x, int y, int width, int height, Component narration, ImmutableList<Option<T>> options, T selectedValue, Consumer<T> onChanged) {
-		super(x, y, width, height, Option.find(options, selectedValue).getText(), options.indexOf(Option.find(options, selectedValue)) / (options.size() - 1.0));
+		super(x, y, width, height, Option.find(options, selectedValue).text(), getOptionValue(options, options.indexOf(Option.find(options, selectedValue))));
+		this.narration = narration;
 		this.options = options;
 		this.selectedValue = selectedValue;
 		this.onChanged = onChanged;
 	}
 	
-	public DiscreteValueSliderWidget(final int x, final int y, final int width, final List<Option<T>> options, final T selectedValue, final Consumer<T> onChanged){
+	public DiscreteValueSliderWidget(int x, int y, int width, Component narration, ImmutableList<Option<T>> options, T selectedValue, Consumer<T> onChanged) {
-		this(x, y, width, 20, options, selectedValue, onChanged);
+		this(x, y, width, 20, narration, options, selectedValue, onChanged);
 	}
 	
-	public Option<T> getSelectedOption(){
+	public Option<T> getSelectedOption() {
-		return options.get(MathHelper.floor(MathHelper.clampedLerp(0.0, options.size() - 1.0, value)));
+		return options.get(getSelectedOptionIndex());
+	}
+	
+	private int getSelectedOptionIndex() {
+		return Mth.floor(Mth.clampedLerp(0.0, options.size() - 1.0, value));
 	}
 	
 	@Override
-	protected void updateMessage(){
+	protected void updateMessage() {
-		setMessage(getSelectedOption().getText());
+		setMessage(getSelectedOption().text());
 	}
 	
 	@Override
-	protected void applyValue(){
+	public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
-		final T newSelectedValue = getSelectedOption().getValue();
+		if (CommonInputs.selected(keyCode)) {
+			return super.keyPressed(keyCode, scanCode, modifiers);
+		}
 		
-		if (selectedValue != newSelectedValue){
+		if (keyCode == GLFW.GLFW_KEY_LEFT || keyCode == GLFW.GLFW_KEY_RIGHT) {
+			int newOptionIndex = keyCode == GLFW.GLFW_KEY_LEFT
+				? getSelectedOptionIndex() - 1
+				: getSelectedOptionIndex() + 1;
+			
+			if (newOptionIndex >= 0 && newOptionIndex < options.size()) {
+				value = getOptionValue(options, newOptionIndex);
+				applyValue();
+				updateMessage();
+			}
+			
+			return true;
+		}
+		
+		return false;
+	}
+	
+	@Override
+	protected void applyValue() {
+		T newSelectedValue = getSelectedOption().value();
+		
+		if (selectedValue != newSelectedValue) {
 			selectedValue = newSelectedValue;
 			onChanged.accept(newSelectedValue);
 		}
 	}
+	
+	@NotNull
+	@Override
+	protected MutableComponent createNarrationMessage() {
+		return Component.translatable("gui.narrate.slider", narration.plainCopy().append(" ").append(getMessage()));
+	}
+	
+	private static <T> double getOptionValue(ImmutableList<Option<T>> options, int optionIndex) {
+		return optionIndex / (options.size() - 1.0);
+	}
 }

src/main/java/chylex/bettercontrols/gui/elements/KeyBindingWidget.java

@@ -1,89 +1,91 @@
 package chylex.bettercontrols.gui.elements;
-import net.minecraft.client.MinecraftClient;
+
-import net.minecraft.client.gui.widget.AbstractButtonWidget;
+import com.mojang.blaze3d.platform.InputConstants;
-import net.minecraft.client.gui.widget.ButtonWidget;
+import net.minecraft.ChatFormatting;
-import net.minecraft.client.options.KeyBinding;
+import net.minecraft.client.KeyMapping;
-import net.minecraft.client.util.InputUtil;
+import net.minecraft.client.Minecraft;
-import net.minecraft.text.LiteralText;
+import net.minecraft.client.gui.components.AbstractButton;
-import net.minecraft.text.MutableText;
+import net.minecraft.client.gui.components.Button;
-import net.minecraft.text.Text;
+import net.minecraft.network.chat.Component;
-import net.minecraft.text.TranslatableText;
+import net.minecraft.network.chat.MutableComponent;
-import net.minecraft.util.Formatting;
+import org.jetbrains.annotations.NotNull;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;
 
-public final class KeyBindingWidget extends ButtonWidget{
+public final class KeyBindingWidget extends Button {
-	private final KeyBinding binding;
+	private final KeyMapping binding;
-	private final Text bindingName;
+	private final Component bindingName;
 	
-	private final List<AbstractButtonWidget> linkedButtons = new ArrayList<>(1);
+	private final List<AbstractButton> linkedButtons = new ArrayList<>(1);
 	
 	private final Consumer<KeyBindingWidget> onEditingStarted;
 	private boolean isEditing;
 	
-	public KeyBindingWidget(final int x, final int y, final int width, final int height, final KeyBinding binding, final Consumer<KeyBindingWidget> onEditingStarted){
+	public KeyBindingWidget(int x, int y, int width, int height, Component bindingName, KeyMapping binding, Consumer<KeyBindingWidget> onEditingStarted) {
-		super(x, y, width, height, LiteralText.EMPTY, btn -> {});
+		super(x, y, width, height, Component.empty(), btn -> {}, DEFAULT_NARRATION);
 		this.binding = binding;
-		this.bindingName = new TranslatableText(binding.getTranslationKey());
+		this.bindingName = bindingName;
 		this.onEditingStarted = onEditingStarted;
 		updateKeyBindingText();
 	}
 	
-	public KeyBindingWidget(final int x, final int y, final int width, final KeyBinding binding, final Consumer<KeyBindingWidget> onEditingStarted){
+	public KeyBindingWidget(int x, int y, int width, Component bindingName, KeyMapping binding, Consumer<KeyBindingWidget> onEditingStarted) {
-		this(x, y, width, 20, binding, onEditingStarted);
+		this(x, y, width, 20, bindingName, binding, onEditingStarted);
 	}
 	
-	public void linkButtonToBoundState(final AbstractButtonWidget button){
+	public void linkButtonToBoundState(AbstractButton button) {
 		linkedButtons.add(button);
 		button.active = !binding.isUnbound();
 	}
 	
+	@NotNull
 	@Override
-	protected MutableText getNarrationMessage(){
+	protected MutableComponent createNarrationMessage() {
-		return binding.isUnbound() ? new TranslatableText("narrator.controls.unbound", bindingName) : new TranslatableText("narrator.controls.bound", bindingName, super.getNarrationMessage());
+		return binding.isUnbound() ? Component.translatable("narrator.controls.unbound", bindingName) : Component.translatable("narrator.controls.bound", bindingName, super.createNarrationMessage());
 	}
 	
 	@Override
-	public void onPress(){
+	public void onPress() {
 		isEditing = true;
 		onEditingStarted.accept(this);
 		updateKeyBindingText();
 	}
 	
-	public void bindAndStopEditing(final InputUtil.Key key){
+	public void bindAndStopEditing(InputConstants.Key key) {
-		binding.setBoundKey(key);
+		binding.setKey(key);
 		stopEditing();
 		
-		for(final AbstractButtonWidget button : linkedButtons){
+		for (AbstractButton button : linkedButtons) {
 			button.active = !binding.isUnbound();
 		}
 	}
 	
-	public void stopEditing(){
+	public void stopEditing() {
 		isEditing = false;
 		updateKeyBindingText();
 	}
 	
-	public void updateKeyBindingText(){
+	public void updateKeyBindingText() {
 		boolean hasConflict = false;
 		
-		if (!binding.isUnbound()){
+		if (!binding.isUnbound()) {
-			for(final KeyBinding other : MinecraftClient.getInstance().options.keysAll){
+			for (KeyMapping other : Minecraft.getInstance().options.keyMappings) {
-				if (binding != other && binding.equals(other)){
+				if (binding != other && binding.same(other)) {
 					hasConflict = true;
+					break;
 				}
 			}
 		}
 		
-		if (isEditing){
+		if (isEditing) {
-			setMessage((new LiteralText("> ")).append(binding.getBoundKeyLocalizedText().shallowCopy().formatted(Formatting.YELLOW)).append(" <").formatted(Formatting.YELLOW));
+			setMessage(Component.literal("> ").append(binding.getTranslatedKeyMessage().copy().withStyle(ChatFormatting.YELLOW)).append(" <").withStyle(ChatFormatting.YELLOW));
 		}
-		else if (hasConflict){
+		else if (hasConflict) {
-			setMessage(binding.getBoundKeyLocalizedText().shallowCopy().formatted(Formatting.RED));
+			setMessage(binding.getTranslatedKeyMessage().copy().withStyle(ChatFormatting.RED));
 		}
-		else{
+		else {
-			setMessage(binding.isUnbound() ? Text.of("(No Binding)") : binding.getBoundKeyLocalizedText());
+			setMessage(binding.isUnbound() ? Component.literal("(No Binding)") : binding.getTranslatedKeyMessage());
 		}
 	}
 }

src/main/java/chylex/bettercontrols/gui/elements/Option.java

@@ -1,26 +1,21 @@
 package chylex.bettercontrols.gui.elements;
-import net.minecraft.text.Text;
+
+import net.minecraft.client.gui.components.CycleButton;
+import net.minecraft.network.chat.Component;
 import java.util.List;
 import java.util.Objects;
+import java.util.function.Consumer;
 
-public final class Option<T>{
+public record Option<T>(T value, Component text) {
-	private final T value;
+	public static <T> Option<T> find(List<Option<T>> options, T value) {
-	private final Text text;
-	
-	public Option(final T value, final Text text){
-		this.value = value;
-		this.text = text;
-	}
-	
-	public T getValue(){
-		return value;
-	}
-	
-	public Text getText(){
-		return text;
-	}
-	
-	public static <T> Option<T> find(final List<Option<T>> options, final T value){
 		return options.stream().filter(it -> Objects.equals(it.value, value)).findFirst().orElseGet(() -> options.get(0));
 	}
+	
+	public static <T> CycleButton<Option<T>> button(int x, int y, int width, Component text, List<Option<T>> options, T initialValue, Consumer<T> onValueChanged) {
+		return CycleButton.<Option<T>>builder(Option::text)
+			.displayOnlyValue()
+			.withValues(options)
+			.withInitialValue(find(options, initialValue))
+			.create(x, y, width, 20, text, (btn, newValue) -> onValueChanged.accept(newValue.value()));
+	}
 }

src/main/java/chylex/bettercontrols/gui/elements/TextWidget.java

@@ -1,25 +1,28 @@
 package chylex.bettercontrols.gui.elements;
-import chylex.bettercontrols.gui.OptionListWidget.Widget;
+
-import net.minecraft.client.MinecraftClient;
+import chylex.bettercontrols.gui.OptionListWidget.OptionWidget;
-import net.minecraft.client.font.TextRenderer;
+import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.DrawableHelper;
+import net.minecraft.client.gui.Font;
-import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.text.OrderedText;
+import net.minecraft.network.chat.Component;
-import net.minecraft.text.Text;
+import net.minecraft.util.FormattedCharSequence;
+import org.jetbrains.annotations.NotNull;
 import java.util.List;
 
-public final class TextWidget extends DrawableHelper implements Widget{
+public final class TextWidget implements OptionWidget {
 	public static final int LEFT = 0;
 	public static final int CENTER = 1;
 	
-	private final Text text;
+	public static final int WHITE = 0xFF_FF_FF_FF;
+	
+	private final Component text;
 	private int x;
 	private int y;
 	private final int width;
 	private final int height;
 	private final int align;
 	
-	public TextWidget(final int x, final int y, final int width, final int height, final Text text, final int align){
+	public TextWidget(int x, int y, int width, int height, Component text, int align) {
 		this.x = x;
 		this.y = y;
 		this.width = width;
@@ -28,46 +31,58 @@ public final class TextWidget extends DrawableHelper implements Widget{
 		this.align = align;
 	}
 	
-	public TextWidget(final int x, final int y, final int width, final Text text, final int align){
+	public TextWidget(int x, int y, int width, Component text, int align) {
 		this(x, y, width, 20, text, align);
 	}
 	
-	public TextWidget(final int x, final int y, final int width, final Text text){
+	public TextWidget(int x, int y, int width, Component text) {
 		this(x, y, width, 20, text, LEFT);
 	}
 	
 	@Override
-	public int getX(){
+	public void setX(int x) {
-		return x;
-	}
-	
-	@Override
-	public int getY(){
-		return y;
-	}
-	
-	@Override
-	public void setX(final int x){
 		this.x = x;
 	}
 	
 	@Override
-	public void setY(final int y){
+	public int getX() {
+		return x;
+	}
+	
+	@Override
+	public void setY(int y) {
 		this.y = y;
 	}
 	
 	@Override
-	public void render(final MatrixStack matrices, final int mouseX, final int mouseY, final float delta){
+	public int getY() {
-		final TextRenderer textRenderer = MinecraftClient.getInstance().textRenderer;
+		return y;
-		final List<OrderedText> lines = textRenderer.wrapLines(text, width);
+	}
-		final int lineHeight = textRenderer.fontHeight + 1;
+	
+	@Override
+	public int getHeight() {
+		return height;
+	}
+	
+	@Override
+	public void setFocused(boolean focused) {}
+	
+	@Override
+	public boolean isFocused() {
+		return false;
+	}
+	
+	@Override
+	public void render(@NotNull GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+		Font textRenderer = Minecraft.getInstance().font;
+		List<FormattedCharSequence> lines = textRenderer.split(text, width);
+		final int lineHeight = textRenderer.lineHeight + 1;
 		
-		final int finalX = align == CENTER ? x + (width / 2) - (lines.stream().mapToInt(textRenderer::getWidth).max().orElse(0) / 2) : x;
+		int finalX = align == CENTER ? x + (width / 2) - (lines.stream().mapToInt(textRenderer::width).max().orElse(0) / 2) : x;
-		final int finalY = y + (height / 2) - (lineHeight * lines.size() / 2) + 1;
+		int finalY = y + (height / 2) - (lineHeight * lines.size() / 2) + 1;
 		
-		for(int i = 0; i < lines.size(); i++){
+		for (int i = 0; i < lines.size(); i++) {
-			final OrderedText line = lines.get(i);
+			graphics.drawString(textRenderer, lines.get(i), finalX, finalY + (i * lineHeight), WHITE);
-			textRenderer.drawWithShadow(matrices, line, finalX, finalY + (i * lineHeight), (255 << 16) | (255 << 8) | 255);
 		}
 	}
 }

src/main/java/chylex/bettercontrols/input/KeyBindingWithModifier.java

@@ -1,39 +1,35 @@
 package chylex.bettercontrols.input;
-import net.minecraft.client.options.KeyBinding;
+
-import net.minecraft.client.util.InputUtil.Type;
+import com.mojang.blaze3d.platform.InputConstants.Type;
-import net.minecraft.text.Text;
+import net.minecraft.client.KeyMapping;
-import net.minecraft.text.TranslatableText;
 import org.jetbrains.annotations.Nullable;
 
-public class KeyBindingWithModifier extends KeyBinding{
+public class KeyBindingWithModifier extends KeyMapping {
 	public static final String CATEGORY = "key.categories.bettercontrols";
 	
-	public static boolean checkCategoryMatches(final Text text){
-		return text instanceof TranslatableText && CATEGORY.equals(((TranslatableText)text).getKey());
-	}
-	
 	@Nullable
 	private ModifierKey modifier = null;
 	
-	public KeyBindingWithModifier(final String translationKey){
+	public KeyBindingWithModifier(String translationKey) {
 		super(translationKey, Type.KEYSYM, -1, CATEGORY);
 	}
 	
-	public void setModifier(final @Nullable ModifierKey modifier){
+	public void setModifier(@Nullable ModifierKey modifier) {
 		this.modifier = modifier;
 	}
 	
-	public @Nullable ModifierKey getModifier(){
+	@Nullable
+	public ModifierKey getModifier() {
 		return modifier;
 	}
 	
 	@Override
-	public boolean isPressed(){
+	public boolean isDown() {
-		return super.isPressed() && (modifier == null || modifier.isPressed());
+		return super.isDown() && (modifier == null || modifier.isPressed());
 	}
 	
 	@Override
-	public boolean wasPressed(){
+	public boolean consumeClick() {
-		return super.wasPressed() && (modifier == null || modifier.isPressed());
+		return super.consumeClick() && (modifier == null || modifier.isPressed());
 	}
 }

src/main/java/chylex/bettercontrols/input/ModifierKey.java

@@ -1,42 +1,43 @@
 package chylex.bettercontrols.input;
-import net.minecraft.client.gui.screen.Screen;
 
-public enum ModifierKey{
+import net.minecraft.client.gui.screens.Screen;
-	CONTROL(0){
+
+public enum ModifierKey {
+	CONTROL(0) {
 		@Override
-		public boolean isPressed(){
+		public boolean isPressed() {
 			return Screen.hasControlDown();
 		}
 	},
 	
-	SHIFT(1){
+	SHIFT(1) {
 		@Override
-		public boolean isPressed(){
+		public boolean isPressed() {
 			return Screen.hasShiftDown();
 		}
 	},
 	
-	ALT(2){
+	ALT(2) {
 		@Override
-		public boolean isPressed(){
+		public boolean isPressed() {
 			return Screen.hasAltDown();
 		}
 	};
 	
 	public final int id;
 	
-	ModifierKey(final int id){
+	ModifierKey(int id) {
 		this.id = id;
 	}
 	
 	public abstract boolean isPressed();
 	
-	public static ModifierKey getById(final int id){
+	public static ModifierKey getById(int id) {
-		switch(id){
+		return switch (id) {
-			case 0: return CONTROL;
+			case 0 -> CONTROL;
-			case 1: return SHIFT;
+			case 1 -> SHIFT;
-			case 2: return ALT;
+			case 2 -> ALT;
-			default: return null;
+			default -> null;
-		}
+		};
 	}
 }

src/main/java/chylex/bettercontrols/input/SprintMode.java

@@ -0,0 +1,7 @@
+package chylex.bettercontrols.input;
+
+public enum SprintMode {
+	TAP_TO_START,
+	TAP_TO_TOGGLE,
+	HOLD
+}

src/main/java/chylex/bettercontrols/input/ToggleTracker.java

@@ -1,19 +1,24 @@
 package chylex.bettercontrols.input;
-import net.minecraft.client.options.KeyBinding;
 
-public class ToggleTracker{
+import net.minecraft.client.KeyMapping;
-	protected final KeyBinding bindingToggle;
+
-	protected final KeyBinding bindingReset;
+public class ToggleTracker {
-	
+	protected final KeyMapping bindingToggle;
-	protected boolean isToggled;
+	protected final KeyMapping bindingReset;
 	
+	private boolean isToggled;
 	private boolean waitForRelease;
 	private boolean hasToggledWhileHoldingReset;
 	private boolean skipNextToggle;
 	
-	public ToggleTracker(final KeyBinding bindingToggle, final KeyBinding bindingReset){
+	protected ToggleTracker(KeyMapping bindingToggle, KeyMapping bindingReset, boolean initialState) {
 		this.bindingToggle = bindingToggle;
 		this.bindingReset = bindingReset;
+		this.isToggled = initialState;
+	}
+	
+	public ToggleTracker(KeyMapping bindingToggle, KeyMapping bindingReset) {
+		this(bindingToggle, bindingReset, false);
 	}
 	
 	/*
@@ -40,15 +45,15 @@ public class ToggleTracker{
 	 *   +CTRL, +G, -CTRL, +CTRL, +G, +G  -->  toggled on
 	 */
 	
-	public boolean tick(){
+	public boolean tick() {
-		final boolean isHoldingReset = isResetKeyPressed();
+		boolean isHoldingReset = isResetKeyPressed();
 		
-		if (bindingToggle.isPressed()){
+		if (bindingToggle.isDown()) {
-			if (!waitForRelease){
+			if (!waitForRelease) {
-				if (skipNextToggle){
+				if (skipNextToggle) {
 					skipNextToggle = false;
 				}
-				else{
+				else {
 					isToggled = !isToggled;
 				}
 				
@@ -56,28 +61,33 @@ public class ToggleTracker{
 				hasToggledWhileHoldingReset = isHoldingReset;
 			}
 		}
-		else{
+		else {
 			waitForRelease = false;
 		}
 		
-		if (isToggled){
+		if (isToggled) {
-			if (hasToggledWhileHoldingReset && !isHoldingReset){
+			if (hasToggledWhileHoldingReset && !isHoldingReset) {
 				hasToggledWhileHoldingReset = false;
 			}
-			else if (!hasToggledWhileHoldingReset && isHoldingReset){
+			else if (!hasToggledWhileHoldingReset && isHoldingReset) {
 				isToggled = false;
 				skipNextToggle = true;
 			}
 		}
 		
-		if (skipNextToggle && !isHoldingReset){
+		if (skipNextToggle && !isHoldingReset) {
 			skipNextToggle = false;
 		}
 		
 		return isToggled;
 	}
 	
-	protected boolean isResetKeyPressed(){
+	protected boolean isResetKeyPressed() {
-		return bindingReset.isPressed();
+		return bindingReset.isDown();
+	}
+	
+	public void reset() {
+		isToggled = false;
+		waitForRelease = false;
 	}
 }

src/main/java/chylex/bettercontrols/input/ToggleTrackerForStickyKey.java

@@ -1,35 +1,36 @@
 package chylex.bettercontrols.input;
-import chylex.bettercontrols.mixin.AccessKeyBindingFields;
+
-import it.unimi.dsi.fastutil.booleans.BooleanConsumer;
+import chylex.bettercontrols.Mixins;
-import net.minecraft.client.options.KeyBinding;
+import net.minecraft.client.KeyMapping;
+import net.minecraft.client.OptionInstance;
 import java.util.HashSet;
 import java.util.Set;
 
-public final class ToggleTrackerForStickyKey extends ToggleTracker{
+public final class ToggleTrackerForStickyKey extends ToggleTracker {
-	private static final Set<KeyBinding> enabledOverrides = new HashSet<>();
+	private static final Set<KeyMapping> enabledOverrides = new HashSet<>();
 	
-	public static boolean isOverrideEnabled(final KeyBinding binding){
+	@SuppressWarnings("StaticMethodOnlyUsedInOneClass")
+	public static boolean isOverrideEnabled(KeyMapping binding) {
 		return enabledOverrides.contains(binding);
 	}
 	
-	private final BooleanConsumer setToggleState;
+	private final OptionInstance<Boolean> toggleOption;
 	
-	public ToggleTrackerForStickyKey(final KeyBinding bindingToggle, final KeyBinding bindingStickyReset, final BooleanConsumer setToggleState){
+	public ToggleTrackerForStickyKey(KeyMapping bindingToggle, KeyMapping bindingStickyReset, OptionInstance<Boolean> toggleOption) {
-		super(bindingToggle, bindingStickyReset);
+		super(bindingToggle, bindingStickyReset, toggleOption.get().booleanValue());
-		this.setToggleState = setToggleState;
+		this.toggleOption = toggleOption;
-		this.setToggleState.accept(false);
 		enabledOverrides.add(bindingStickyReset);
 	}
 	
 	@Override
-	public boolean tick(){
+	public boolean tick() {
-		final boolean isToggled = super.tick();
+		boolean isToggled = super.tick();
-		setToggleState.accept(isToggled);
+		toggleOption.set(Boolean.valueOf(isToggled));
 		return isToggled;
 	}
 	
 	@Override
-	protected boolean isResetKeyPressed(){
+	protected boolean isResetKeyPressed() {
-		return ((AccessKeyBindingFields)bindingReset).isPressedField();
+		return Mixins.keyMappingFields(bindingReset).isPressedField();
 	}
 }

src/main/java/chylex/bettercontrols/mixin/AccessCameraFields.java

@@ -1,14 +1,11 @@
 package chylex.bettercontrols.mixin;
-import net.minecraft.client.render.Camera;
+
-import net.minecraft.entity.Entity;
+import net.minecraft.client.Camera;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.gen.Accessor;
 
 @Mixin(Camera.class)
-public interface AccessCameraFields{
+public interface AccessCameraFields {
 	@Accessor
-	Entity getFocusedEntity();
+	void setEyeHeight(float y);
-	
-	@Accessor
-	void setCameraY(float y);
 }

src/main/java/chylex/bettercontrols/mixin/AccessClientPlayerFields.java

@@ -1,10 +1,11 @@
 package chylex.bettercontrols.mixin;
-import net.minecraft.client.network.ClientPlayerEntity;
+
+import net.minecraft.client.player.LocalPlayer;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.gen.Accessor;
 
-@Mixin(ClientPlayerEntity.class)
+@Mixin(LocalPlayer.class)
-public interface AccessClientPlayerFields{
+public interface AccessClientPlayerFields {
 	@Accessor
-	void setTicksLeftToDoubleTapSprint(int value);
+	void setSprintTriggerTime(int value);
 }

src/main/java/chylex/bettercontrols/mixin/AccessControlsListCategory.java

@@ -1,11 +0,0 @@
-package chylex.bettercontrols.mixin;
-import net.minecraft.client.gui.screen.options.ControlsListWidget.CategoryEntry;
-import net.minecraft.text.Text;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Accessor;
-
-@Mixin(CategoryEntry.class)
-public interface AccessControlsListCategory{
-	@Accessor
-	Text getText();
-}

src/main/java/chylex/bettercontrols/mixin/AccessControlsListKeyBinding.java

@@ -1,11 +0,0 @@
-package chylex.bettercontrols.mixin;
-import net.minecraft.client.gui.screen.options.ControlsListWidget.KeyBindingEntry;
-import net.minecraft.client.options.KeyBinding;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Accessor;
-
-@Mixin(KeyBindingEntry.class)
-public interface AccessControlsListKeyBinding{
-	@Accessor
-	KeyBinding getBinding();
-}

src/main/java/chylex/bettercontrols/mixin/AccessKeyBindingFields.java

@@ -1,19 +0,0 @@
-package chylex.bettercontrols.mixin;
-import net.minecraft.client.options.KeyBinding;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Accessor;
-import java.util.Map;
-
-@Mixin(KeyBinding.class)
-public interface AccessKeyBindingFields{
-	@Accessor
-	static Map<String, Integer> getCategoryOrderMap(){
-		throw new AssertionError();
-	}
-	
-	@Accessor("pressed")
-	boolean isPressedField();
-	
-	@Accessor("pressed")
-	void setPressedField(boolean value);
-}

src/main/java/chylex/bettercontrols/mixin/AccessKeyMappingFields.java

@@ -0,0 +1,21 @@
+package chylex.bettercontrols.mixin;
+
+import net.minecraft.client.KeyMapping;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import java.util.Map;
+
+@Mixin(KeyMapping.class)
+@SuppressWarnings("StaticMethodOnlyUsedInOneClass")
+public interface AccessKeyMappingFields {
+	@Accessor("CATEGORY_SORT_ORDER")
+	static Map<String, Integer> getCategoryOrderMap() {
+		throw new AssertionError();
+	}
+	
+	@Accessor("isDown")
+	boolean isPressedField();
+	
+	@Accessor("isDown")
+	void setPressedField(boolean value);
+}

src/main/java/chylex/bettercontrols/mixin/AccessPlayerFields.java

@@ -0,0 +1,11 @@
+package chylex.bettercontrols.mixin;
+
+import net.minecraft.world.entity.player.Player;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(Player.class)
+public interface AccessPlayerFields {
+	@Accessor
+	void setJumpTriggerTime(int value);
+}

src/main/java/chylex/bettercontrols/mixin/AccessScreenButtons.java

@@ -1,16 +0,0 @@
-package chylex.bettercontrols.mixin;
-import net.minecraft.client.gui.screen.Screen;
-import net.minecraft.client.gui.widget.AbstractButtonWidget;
-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(Screen.class)
-public interface AccessScreenButtons{
-	@Accessor
-	List<AbstractButtonWidget> getButtons();
-	
-	@Invoker
-	<T extends AbstractButtonWidget> T callAddButton(T button);
-}

src/main/java/chylex/bettercontrols/mixin/AccessToggleKeyMappingFields.java

@@ -0,0 +1,17 @@
+package chylex.bettercontrols.mixin;
+
+import net.minecraft.client.ToggleKeyMapping;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import java.util.function.BooleanSupplier;
+
+@Mixin(ToggleKeyMapping.class)
+public interface AccessToggleKeyMappingFields {
+	@Accessor
+	BooleanSupplier getNeedsToggle();
+	
+	@Accessor
+	@Mutable
+	void setNeedsToggle(BooleanSupplier toggleGetter);
+}

src/main/java/chylex/bettercontrols/mixin/HookClientPlayerFOV.java

@@ -0,0 +1,27 @@
+package chylex.bettercontrols.mixin;
+
+import chylex.bettercontrols.Mixins;
+import chylex.bettercontrols.player.PlayerTicker;
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import net.minecraft.client.player.AbstractClientPlayer;
+import net.minecraft.client.player.LocalPlayer;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+
+@Mixin(AbstractClientPlayer.class)
+public abstract class HookClientPlayerFOV {
+	@ModifyExpressionValue(
+		method = "getFieldOfViewModifier",
+		at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/player/Abilities;getWalkingSpeed()F")
+	)
+	private float overrideWalkingSpeed(float walkingSpeed) {
+		AbstractClientPlayer me = Mixins.me(this);
+		
+		if (me instanceof LocalPlayer localPlayer && PlayerTicker.shouldResetFOV(localPlayer)) {
+			return 0F;
+		}
+		else {
+			return walkingSpeed;
+		}
+	}
+}

src/main/java/chylex/bettercontrols/mixin/HookClientPlayerInputTick.java

@@ -1,8 +1,9 @@
 package chylex.bettercontrols.mixin;
+
 import chylex.bettercontrols.player.PlayerTicker;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.Minecraft;
-import net.minecraft.client.input.KeyboardInput;
+import net.minecraft.client.player.KeyboardInput;
-import net.minecraft.client.network.ClientPlayerEntity;
+import net.minecraft.client.player.LocalPlayer;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -10,14 +11,17 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import static org.spongepowered.asm.mixin.injection.At.Shift.AFTER;
 
 @Mixin(KeyboardInput.class)
-public abstract class HookClientPlayerInputTick{
+@SuppressWarnings("MethodMayBeStatic")
-	@Inject(method = "tick(Z)V", at = @At(value = "FIELD", target = "Lnet/minecraft/client/input/KeyboardInput;pressingForward:Z", ordinal = 0, shift = AFTER))
+public abstract class HookClientPlayerInputTick {
-	private void afterInputTick(final CallbackInfo info){
+	@Inject(
-		final KeyboardInput input = (KeyboardInput)(Object)this;
+		method = "tick",
-		final ClientPlayerEntity player = MinecraftClient.getInstance().player;
+		at = @At(value = "FIELD", target = "Lnet/minecraft/client/player/KeyboardInput;keyPresses:Lnet/minecraft/world/entity/player/Input;", ordinal = 0, shift = AFTER)
+	)
+	private void afterInputTick(CallbackInfo info) {
+		LocalPlayer player = Minecraft.getInstance().player;
 		
-		if (player != null){
+		if (player != null) {
-			PlayerTicker.get(player).afterInputAssignsPressingForward(input);
+			PlayerTicker.get(player).afterKeyboardInputAssigned(player);
 		}
 	}
 }

src/main/java/chylex/bettercontrols/mixin/HookClientPlayerTick.java

@@ -1,36 +1,38 @@
 package chylex.bettercontrols.mixin;
+
+import chylex.bettercontrols.Mixins;
 import chylex.bettercontrols.player.PlayerTicker;
 import com.mojang.authlib.GameProfile;
-import net.minecraft.client.network.AbstractClientPlayerEntity;
+import net.minecraft.client.multiplayer.ClientLevel;
-import net.minecraft.client.network.ClientPlayerEntity;
+import net.minecraft.client.player.AbstractClientPlayer;
-import net.minecraft.client.world.ClientWorld;
+import net.minecraft.client.player.LocalPlayer;
 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;
 import static org.spongepowered.asm.mixin.injection.At.Shift.AFTER;
 
-@Mixin(ClientPlayerEntity.class)
+@Mixin(LocalPlayer.class)
-public abstract class HookClientPlayerTick extends AbstractClientPlayerEntity{
+public abstract class HookClientPlayerTick extends AbstractClientPlayer {
-	protected HookClientPlayerTick(final ClientWorld world, final GameProfile profile){
+	protected HookClientPlayerTick(ClientLevel world, GameProfile profile) {
 		super(world, profile);
 	}
 	
-	@Inject(method = "tickMovement()V", at = @At("HEAD"))
+	@Inject(method = "aiStep()V", at = @At("HEAD"))
-	private void atHead(final CallbackInfo info){
+	private void atHead(CallbackInfo info) {
-		final ClientPlayerEntity player = (ClientPlayerEntity)(Object)this;
+		LocalPlayer player = Mixins.me(this);
 		PlayerTicker.get(player).atHead(player);
 	}
 	
-	@Inject(method = "tickMovement()V", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/input/Input;tick(Z)V", ordinal = 0, shift = AFTER))
+	@Inject(method = "aiStep()V", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/player/ClientInput;tick()V", ordinal = 0, shift = AFTER))
-	private void afterInputTick(final CallbackInfo info){
+	private void afterInputTick(CallbackInfo info) {
-		final ClientPlayerEntity player = (ClientPlayerEntity)(Object)this;
+		LocalPlayer player = Mixins.me(this);
 		PlayerTicker.get(player).afterInputTick(player);
 	}
 	
-	@Inject(method = "tickMovement()V", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/network/AbstractClientPlayerEntity;tickMovement()V", ordinal = 0, shift = AFTER))
+	@Inject(method = "aiStep()V", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/player/AbstractClientPlayer;aiStep()V", ordinal = 0, shift = AFTER))
-	private void afterSuperCall(final CallbackInfo info){
+	private void afterSuperCall(CallbackInfo info) {
-		final ClientPlayerEntity player = (ClientPlayerEntity)(Object)this;
+		LocalPlayer player = Mixins.me(this);
 		PlayerTicker.get(player).afterSuperCall(player);
 	}
 }

src/main/java/chylex/bettercontrols/mixin/HookClientPlayerVerticalFlightSpeed.java

@@ -0,0 +1,32 @@
+package chylex.bettercontrols.mixin;
+
+import chylex.bettercontrols.Mixins;
+import chylex.bettercontrols.player.FlightHelper;
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import net.minecraft.client.player.LocalPlayer;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.level.Level;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Slice;
+
+@Mixin(LocalPlayer.class)
+public abstract class HookClientPlayerVerticalFlightSpeed extends LivingEntity {
+	protected HookClientPlayerVerticalFlightSpeed(EntityType<? extends LivingEntity> type, Level world) {
+		super(type, world);
+	}
+	
+	@ModifyExpressionValue(
+		method = "aiStep",
+		at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/player/Abilities;getFlyingSpeed()F"),
+		slice = @Slice(
+			from = @At(value = "FIELD", target = "Lnet/minecraft/world/entity/player/Abilities;flying:Z"),
+			to = @At(value = "INVOKE", target = "Lnet/minecraft/client/player/LocalPlayer;setDeltaMovement(Lnet/minecraft/world/phys/Vec3;)V")
+		)
+	)
+	private float modifyVerticalFlightSpeed(float flyingSpeed) {
+		LocalPlayer me = Mixins.me(this);
+		return flyingSpeed * FlightHelper.getVerticalSpeedMultiplier(me);
+	}
+}

src/main/java/chylex/bettercontrols/mixin/HookControlsListWidget.java

@@ -1,37 +1,27 @@
 package chylex.bettercontrols.mixin;
-import chylex.bettercontrols.BetterControlsMod;
+
-import chylex.bettercontrols.input.KeyBindingWithModifier;
+import chylex.bettercontrols.BetterControlsCommon;
-import net.minecraft.client.MinecraftClient;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
-import net.minecraft.client.gui.screen.options.ControlsListWidget;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
-import net.minecraft.client.gui.screen.options.ControlsListWidget.CategoryEntry;
+import net.minecraft.client.KeyMapping;
-import net.minecraft.client.gui.screen.options.ControlsListWidget.Entry;
+import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.screen.options.ControlsListWidget.KeyBindingEntry;
+import net.minecraft.client.Options;
-import net.minecraft.client.gui.screen.options.ControlsOptionsScreen;
+import net.minecraft.client.gui.components.ContainerObjectSelectionList;
-import net.minecraft.client.gui.widget.ElementListWidget;
+import net.minecraft.client.gui.screens.options.controls.KeyBindsList;
+import net.minecraft.client.gui.screens.options.controls.KeyBindsList.Entry;
 import org.apache.commons.lang3.ArrayUtils;
 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(ControlsListWidget.class)
+@Mixin(KeyBindsList.class)
-public abstract class HookControlsListWidget extends ElementListWidget<Entry>{
+@SuppressWarnings("MethodMayBeStatic")
-	public HookControlsListWidget(final MinecraftClient client, final int width, final int height, final int top, final int bottom, final int itemHeight){
+public abstract class HookControlsListWidget extends ContainerObjectSelectionList<Entry> {
-		super(client, width, height, top, bottom, itemHeight);
+	public HookControlsListWidget(Minecraft client, int width, int height, int top, int itemHeight) {
+		super(client, width, height, top, itemHeight);
 	}
 	
-	@Inject(method = "<init>", at = @At("TAIL"))
+	@WrapOperation(method = "<init>", at = @At(value = "FIELD", target = "Lnet/minecraft/client/Options;keyMappings:[Lnet/minecraft/client/KeyMapping;"))
-	public void init(final ControlsOptionsScreen parent, final MinecraftClient client, final CallbackInfo ci){
+	private KeyMapping[] excludeOwnKeyBindings(Options options, Operation<KeyMapping[]> operation) {
-		children().removeIf(it -> {
+		return ArrayUtils.removeElements(operation.call(options), BetterControlsCommon.getConfig().getAllKeyBindings());
-			if (it instanceof CategoryEntry && KeyBindingWithModifier.checkCategoryMatches(((AccessControlsListCategory)it).getText())){
-				return true;
-			}
-			
-			if (it instanceof KeyBindingEntry && ArrayUtils.contains(BetterControlsMod.config.getAllKeyBindings(), ((AccessControlsListKeyBinding)it).getBinding())){
-				return true;
-			}
-			
-			return false;
-		});
 	}
 }

src/main/java/chylex/bettercontrols/mixin/HookControlsScreen.java

@@ -0,0 +1,39 @@
+package chylex.bettercontrols.mixin;
+
+import chylex.bettercontrols.Mixins;
+import chylex.bettercontrols.gui.BetterControlsScreen;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.Options;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.gui.screens.options.OptionsSubScreen;
+import net.minecraft.client.gui.screens.options.controls.ControlsScreen;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import java.util.List;
+
+@Mixin(ControlsScreen.class)
+public abstract class HookControlsScreen extends OptionsSubScreen {
+	public HookControlsScreen(Screen parentScreen, Options options, Component title) {
+		super(parentScreen, options, title);
+	}
+	
+	@Inject(method = "addOptions", at = @At("RETURN"))
+	public void afterAddOptions(CallbackInfo ci) {
+		if (list != null) {
+			ControlsScreen screen = Mixins.me(this);
+			MutableComponent buttonTitle = BetterControlsScreen.TITLE.plainCopy().append("...");
+			list.addSmall(List.of(Button.builder(buttonTitle, btn -> showOptionsScreen(screen)).build()));
+		}
+	}
+	
+	@Unique
+	private static void showOptionsScreen(ControlsScreen screen) {
+		Minecraft.getInstance().setScreen(new BetterControlsScreen(screen));
+	}
+}

src/main/java/chylex/bettercontrols/mixin/HookLoadGameOptions.java

@@ -1,34 +1,43 @@
 package chylex.bettercontrols.mixin;
-import chylex.bettercontrols.BetterControlsMod;
+
+import chylex.bettercontrols.BetterControlsCommon;
+import chylex.bettercontrols.config.BetterControlsConfig;
 import chylex.bettercontrols.input.KeyBindingWithModifier;
-import net.minecraft.client.options.GameOptions;
+import net.minecraft.client.KeyMapping;
-import net.minecraft.client.options.KeyBinding;
+import net.minecraft.client.Options;
 import org.apache.commons.lang3.ArrayUtils;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Mutable;
 import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-@Mixin(GameOptions.class)
+@Mixin(Options.class)
-public abstract class HookLoadGameOptions{
+public abstract class HookLoadGameOptions {
+	@Unique
 	private boolean hasLoaded = false;
 	
 	@Mutable
 	@Final
 	@Shadow
-	public KeyBinding[] keysAll;
+	public KeyMapping[] keyMappings;
 	
 	@Inject(method = "load()V", at = @At("HEAD"))
-	private void load(final CallbackInfo info){
+	private void load(CallbackInfo info) {
-		if (hasLoaded){
+		if (hasLoaded) {
+			return;
+		}
+		
+		BetterControlsConfig config = BetterControlsCommon.getConfig();
+		if (config == null) {
 			return;
 		}
 		
 		hasLoaded = true;
-		keysAll = ArrayUtils.addAll(keysAll, BetterControlsMod.config.getAllKeyBindings());
+		keyMappings = ArrayUtils.addAll(keyMappings, config.getAllKeyBindings());
-		AccessKeyBindingFields.getCategoryOrderMap().put(KeyBindingWithModifier.CATEGORY, Integer.valueOf(Integer.MAX_VALUE));
+		AccessKeyMappingFields.getCategoryOrderMap().put(KeyBindingWithModifier.CATEGORY, Integer.valueOf(Integer.MAX_VALUE));
 	}
 }

src/main/java/chylex/bettercontrols/mixin/HookOpenScreen.java

@@ -1,28 +0,0 @@
-package chylex.bettercontrols.mixin;
-import chylex.bettercontrols.gui.ScreenPatcher;
-import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.gui.screen.Screen;
-import net.minecraft.client.gui.screen.options.AccessibilityOptionsScreen;
-import net.minecraft.client.gui.screen.options.ControlsOptionsScreen;
-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(value = MinecraftClient.class, priority = 100)
-public abstract class HookOpenScreen{
-	@Inject(method = "openScreen(Lnet/minecraft/client/gui/screen/Screen;)V", at = @At("TAIL"))
-	private void openScreen(final Screen ignore, final CallbackInfo ci){
-		final MinecraftClient mc = MinecraftClient.getInstance();
-		final Screen screen = mc.currentScreen;
-		
-		if (screen != null && !Screen.hasAltDown()){
-			if (screen.getClass() == ControlsOptionsScreen.class){
-				ScreenPatcher.onControlsScreenOpened((ControlsOptionsScreen)screen);
-			}
-			else if (screen.getClass() == AccessibilityOptionsScreen.class){
-				ScreenPatcher.onAccessibilityScreenOpened((AccessibilityOptionsScreen)screen);
-			}
-		}
-	}
-}

src/main/java/chylex/bettercontrols/mixin/HookPlayerGliding.java

@@ -0,0 +1,23 @@
+package chylex.bettercontrols.mixin;
+
+import chylex.bettercontrols.player.FlightHelper;
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import net.minecraft.client.player.LocalPlayer;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Slice;
+
+@Mixin(LocalPlayer.class)
+@SuppressWarnings("MethodMayBeStatic")
+public abstract class HookPlayerGliding {
+	@ModifyExpressionValue(
+		method = "aiStep",
+		at = @At(value = "INVOKE:LAST", target = "Lnet/minecraft/world/entity/player/Input;jump()Z"),
+		slice = @Slice(
+			to = @At(value = "INVOKE", target = "Lnet/minecraft/client/player/LocalPlayer;tryToStartFallFlying()Z")
+		)
+	)
+	private boolean shouldStartGliding(boolean isHoldingJump) {
+		return FlightHelper.shouldStartGliding(isHoldingJump);
+	}
+}

src/main/java/chylex/bettercontrols/mixin/HookPlayerHorizontalFlightSpeed.java

@@ -0,0 +1,53 @@
+package chylex.bettercontrols.mixin;
+
+import chylex.bettercontrols.Mixins;
+import chylex.bettercontrols.player.FlightHelper;
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import com.llamalad7.mixinextras.injector.ModifyReturnValue;
+import net.minecraft.client.player.LocalPlayer;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Slice;
+
+@Mixin(Player.class)
+public abstract class HookPlayerHorizontalFlightSpeed extends LivingEntity {
+	protected HookPlayerHorizontalFlightSpeed(EntityType<? extends LivingEntity> type, Level world) {
+		super(type, world);
+	}
+	
+	@SuppressWarnings("SimplifiableIfStatement")
+	@ModifyExpressionValue(
+		method = "getFlyingSpeed",
+		at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/player/Player;isSprinting()Z"),
+		slice = @Slice(
+			from = @At(value = "FIELD", target = "Lnet/minecraft/world/entity/player/Abilities;flying:Z"),
+			to = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/player/Abilities;getFlyingSpeed()F")
+		)
+	)
+	private boolean disableVanillaSprintBoost(boolean isSprinting) {
+		Player me = Mixins.me(this);
+		
+		if (me instanceof LocalPlayer localPlayer && FlightHelper.isFlyingCreativeOrSpectator(localPlayer)) {
+			return false;
+		}
+		else {
+			return isSprinting;
+		}
+	}
+	
+	@ModifyReturnValue(method = "getFlyingSpeed", at = @At("RETURN"))
+	private float modifyHorizontalFlyingSpeed(float flyingSpeed) {
+		Player me = Mixins.me(this);
+		
+		if (me instanceof LocalPlayer localPlayer && localPlayer.getAbilities().flying) {
+			return flyingSpeed * FlightHelper.getHorizontalSpeedMultiplier(localPlayer);
+		}
+		else {
+			return flyingSpeed;
+		}
+	}
+}

src/main/java/chylex/bettercontrols/mixin/HookStickyKeyBindingState.java

@@ -1,7 +1,9 @@
 package chylex.bettercontrols.mixin;
+
+import chylex.bettercontrols.Mixins;
 import chylex.bettercontrols.input.ToggleTrackerForStickyKey;
-import net.minecraft.client.options.KeyBinding;
+import net.minecraft.client.KeyMapping;
-import net.minecraft.client.options.StickyKeyBinding;
+import net.minecraft.client.ToggleKeyMapping;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -10,26 +12,26 @@ import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import java.util.function.BooleanSupplier;
 
-@Mixin(StickyKeyBinding.class)
+@Mixin(ToggleKeyMapping.class)
-public abstract class HookStickyKeyBindingState extends KeyBinding{
+public abstract class HookStickyKeyBindingState extends KeyMapping {
 	@Shadow
 	@Final
-	private BooleanSupplier toggleGetter;
+	private BooleanSupplier needsToggle;
 	
-	public HookStickyKeyBindingState(final String translationKey, final int code, final String category){
+	public HookStickyKeyBindingState(String translationKey, int code, String category) {
 		super(translationKey, code, category);
 	}
 	
-	@Inject(method = "setPressed(Z)V", at = @At("HEAD"), cancellable = true)
+	@Inject(method = "setDown", at = @At("HEAD"), cancellable = true)
-	public void setPressed(final boolean pressed, final CallbackInfo info){
+	public void setPressed(boolean pressed, CallbackInfo info) {
-		if (ToggleTrackerForStickyKey.isOverrideEnabled(this)){
+		if (ToggleTrackerForStickyKey.isOverrideEnabled(this)) {
-			((AccessKeyBindingFields)this).setPressedField(pressed);
+			Mixins.keyMappingFields(this).setPressedField(pressed);
 			info.cancel();
 		}
 	}
 	
 	@Override
-	public boolean isPressed(){
+	public boolean isDown() {
-		return super.isPressed() || (ToggleTrackerForStickyKey.isOverrideEnabled(this) && toggleGetter.getAsBoolean());
+		return super.isDown() || (ToggleTrackerForStickyKey.isOverrideEnabled(this) && needsToggle.getAsBoolean());
 	}
 }

src/main/java/chylex/bettercontrols/mixin/HookToggleOptionButtons.java

@@ -0,0 +1,23 @@
+package chylex.bettercontrols.mixin;
+
+import chylex.bettercontrols.Mixins;
+import net.minecraft.client.OptionInstance;
+import net.minecraft.client.Options;
+import net.minecraft.client.gui.components.AbstractWidget;
+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.CallbackInfoReturnable;
+import java.util.function.Consumer;
+
+@Mixin(OptionInstance.class)
+public abstract class HookToggleOptionButtons {
+	@Inject(method = "createButton(Lnet/minecraft/client/Options;IIILjava/util/function/Consumer;)Lnet/minecraft/client/gui/components/AbstractWidget;", at = @At("RETURN"))
+	private <T> void disableToggleOptions(Options options, int x, int y, int width, Consumer<T> callback, CallbackInfoReturnable<AbstractWidget> cir) {
+		OptionInstance<?> me = Mixins.me(this);
+		
+		if (me == options.toggleCrouch() || me == options.toggleSprint()) {
+			cir.getReturnValue().active = false;
+		}
+	}
+}

src/main/java/chylex/bettercontrols/player/FlightHelper.java

@@ -1,41 +1,52 @@
 package chylex.bettercontrols.player;
-import chylex.bettercontrols.BetterControlsMod;
-import chylex.bettercontrols.config.BetterControlsConfig;
-import net.minecraft.client.network.ClientPlayerEntity;
 
-final class FlightHelper{
+import net.minecraft.client.KeyMapping;
-	private FlightHelper(){}
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.player.LocalPlayer;
+import static chylex.bettercontrols.BetterControlsCommon.getConfig;
+
+public final class FlightHelper {
+	private FlightHelper() {}
 	
-	private static final float BASE_FLIGHT_SPEED = 0.05F;
+	private static final KeyMapping KEY_SPRINT = Minecraft.getInstance().options.keySprint;
-	private static final float BASE_FLIGHT_SPEED_SPRINT_MP_INV = 0.5F; // sprinting doubles speed in PlayerEntity.travel
 	
-	private static BetterControlsConfig cfg(){
+	private static boolean isSprinting() {
-		return BetterControlsMod.config;
+		return KEY_SPRINT.isDown();
 	}
 	
-	static boolean shouldFlyOnGround(final ClientPlayerEntity player){
+	public static boolean shouldStartGliding(boolean isHoldingJump) {
-		return cfg().flyOnGroundInCreative && player.isCreative() && player.abilities.flying;
+		return getConfig().keyStartGlide.isDown() || (getConfig().doubleTapJumpToGlide && isHoldingJump);
 	}
 	
-	static float getFlightSpeed(final ClientPlayerEntity player){
+	public static boolean isFlyingCreativeOrSpectator(LocalPlayer player) {
-		if (player.isCreative()){
+		return player.getAbilities().flying && (player.isCreative() || player.isSpectator());
-			if (player.isSprinting()){
+	}
-				return BASE_FLIGHT_SPEED * cfg().flightSpeedMpCreativeSprinting * BASE_FLIGHT_SPEED_SPRINT_MP_INV;
+	
-			}
+	static boolean shouldFlyOnGround(LocalPlayer player) {
-			else{
+		return getConfig().flyOnGroundInCreative && player.isCreative() && player.getAbilities().flying;
-				return BASE_FLIGHT_SPEED * cfg().flightSpeedMpCreativeDefault;
+	}
-			}
+	
+	public static float getHorizontalSpeedMultiplier(LocalPlayer player) {
+		if (player.isCreative()) {
+			return isSprinting() ? getConfig().flightHorizontalSpeedMpCreativeSprinting : getConfig().flightHorizontalSpeedMpCreativeDefault;
 		}
-		else if (player.isSpectator()){
+		else if (player.isSpectator()) {
-			if (player.isSprinting()){
+			return isSprinting() ? getConfig().flightHorizontalSpeedMpSpectatorSprinting : getConfig().flightHorizontalSpeedMpSpectatorDefault;
-				return BASE_FLIGHT_SPEED * cfg().flightSpeedMpSpectatorSprinting * BASE_FLIGHT_SPEED_SPRINT_MP_INV;
-			}
-			else{
-				return BASE_FLIGHT_SPEED * cfg().flightSpeedMpSpectatorDefault;
-			}
 		}
-		else{
+		else {
-			return 0F;
+			return 1F;
+		}
+	}
+	
+	public static float getVerticalSpeedMultiplier(LocalPlayer player) {
+		if (player.isCreative()) {
+			return isSprinting() ? getConfig().flightVerticalSpeedMpCreativeSprinting : getConfig().flightVerticalSpeedMpCreativeDefault;
+		}
+		else if (player.isSpectator()) {
+			return isSprinting() ? getConfig().flightVerticalSpeedMpSpectatorSprinting : getConfig().flightVerticalSpeedMpSpectatorDefault;
+		}
+		else {
+			return 1F;
 		}
 	}
 }

src/main/java/chylex/bettercontrols/player/PlayerTicker.java

@@ -1,215 +1,293 @@
 package chylex.bettercontrols.player;
-import chylex.bettercontrols.BetterControlsMod;
+
-import chylex.bettercontrols.config.BetterControlsConfig;
+import chylex.bettercontrols.Mixins;
 import chylex.bettercontrols.gui.BetterControlsScreen;
+import chylex.bettercontrols.input.SprintMode;
 import chylex.bettercontrols.input.ToggleTracker;
 import chylex.bettercontrols.input.ToggleTrackerForStickyKey;
-import chylex.bettercontrols.mixin.AccessCameraFields;
+import chylex.bettercontrols.mixin.AccessToggleKeyMappingFields;
-import chylex.bettercontrols.mixin.AccessClientPlayerFields;
+import net.minecraft.client.Camera;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.KeyMapping;
-import net.minecraft.client.input.KeyboardInput;
+import net.minecraft.client.Minecraft;
-import net.minecraft.client.network.ClientPlayerEntity;
+import net.minecraft.client.Options;
-import net.minecraft.client.options.GameOptions;
+import net.minecraft.client.ToggleKeyMapping;
+import net.minecraft.client.player.ClientInput;
+import net.minecraft.client.player.LocalPlayer;
+import net.minecraft.world.entity.player.Input;
 import java.lang.ref.WeakReference;
+import java.util.function.BooleanSupplier;
+import static chylex.bettercontrols.BetterControlsCommon.getConfig;
 
-public final class PlayerTicker{
+public final class PlayerTicker {
+	private static final Minecraft MINECRAFT = Minecraft.getInstance();
+	private static final Options OPTIONS = MINECRAFT.options;
+	
+	private static final ToggleKeyMapping KEY_SPRINT = (ToggleKeyMapping) OPTIONS.keySprint;
+	private static final KeyMapping KEY_SNEAK = OPTIONS.keyShift;
+	private static final KeyMapping KEY_FORWARD = OPTIONS.keyUp;
+	private static final KeyMapping KEY_JUMP = OPTIONS.keyJump;
+	
 	private static PlayerTicker ticker = new PlayerTicker(null);
 	
-	public static PlayerTicker get(final ClientPlayerEntity player){
+	public static PlayerTicker get(LocalPlayer player) {
-		if (ticker.ref.get() != player){
+		if (ticker.ref.get() != player) {
 			ticker = new PlayerTicker(player);
 		}
 		
 		return ticker;
 	}
 	
-	private static MinecraftClient mc(){
+	private final WeakReference<LocalPlayer> ref;
-		return MinecraftClient.getInstance();
-	}
 	
-	private static BetterControlsConfig cfg(){
+	private PlayerTicker(LocalPlayer player) {
-		return BetterControlsMod.config;
-	}
-	
-	private final WeakReference<ClientPlayerEntity> ref;
-	
-	private PlayerTicker(final ClientPlayerEntity player){
 		this.ref = new WeakReference<>(player);
+		setup();
 	}
 	
 	// Logic
 	
-	private final ToggleTracker toggleSprint = new ToggleTrackerForStickyKey(cfg().keyToggleSprint, mc().options.keySprint, toggled -> mc().options.sprintToggled = toggled);
+	private final ToggleTracker toggleSprint = new ToggleTrackerForStickyKey(getConfig().keyToggleSprint, KEY_SPRINT, OPTIONS.toggleSprint());
-	private final ToggleTracker toggleSneak = new ToggleTrackerForStickyKey(cfg().keyToggleSneak, mc().options.keySneak, toggled -> mc().options.sneakToggled = toggled);
+	private final ToggleTracker toggleSneak = new ToggleTrackerForStickyKey(getConfig().keyToggleSneak, KEY_SNEAK, OPTIONS.toggleCrouch());
-	private final ToggleTracker toggleWalkForward = new ToggleTracker(cfg().keyToggleWalkForward, mc().options.keyForward);
+	private final ToggleTracker toggleWalkForward = new ToggleTracker(getConfig().keyToggleWalkForward, KEY_FORWARD);
-	private final ToggleTracker toggleJump = new ToggleTracker(cfg().keyToggleJump, mc().options.keyJump);
+	private final ToggleTracker toggleJump = new ToggleTracker(getConfig().keyToggleJump, KEY_JUMP);
 	
 	private boolean waitingForSprintKeyRelease = false;
 	private boolean stopSprintingAfterReleasingSprintKey = false;
+	
 	private boolean wasHittingObstacle = false;
 	private boolean wasSprintingBeforeHittingObstacle = false;
+	private int temporarySprintTimer = 0;
 	
 	private boolean wasSneakingBeforeTouchingGround = false;
 	private boolean holdingSneakWhileTouchingGround = false;
 	private int temporaryFlyOnGroundTimer = 0;
 	
-	public void atHead(final ClientPlayerEntity player){
+	private void setup() {
-		if (FlightHelper.shouldFlyOnGround(player)){
+		AccessToggleKeyMappingFields sprint = Mixins.toggleKeyMappingFields(KEY_SPRINT);
+		BooleanSupplier getter = sprint.getNeedsToggle();
+		
+		if (getter instanceof SprintPressGetter g) {
+			getter = g.wrapped();
+		}
+		
+		sprint.setNeedsToggle(new SprintPressGetter(getter, () -> temporarySprintTimer > 0));
+	}
+	
+	public void atHead(LocalPlayer player) {
+		if (FlightHelper.shouldFlyOnGround(player)) {
 			player.setOnGround(false);
 		}
 		
-		if (!cfg().doubleTapForwardToSprint){
+		if (!getConfig().doubleTapForwardToSprint) {
-			((AccessClientPlayerFields)player).setTicksLeftToDoubleTapSprint(0);
+			Mixins.clientPlayerFields(player).setSprintTriggerTime(0);
 		}
 		
-		final GameOptions opts = mc().options;
+		if (!getConfig().doubleTapJumpToToggleFlight) {
-		final boolean wasSprintToggled = opts.sprintToggled;
+			Mixins.playerFields(player).setJumpTriggerTime(0);
-		final boolean isSprintToggled = toggleSprint.tick();
+		}
 		
-		if (isSprintToggled){
+		SprintMode sprintMode = getConfig().sprintMode;
+		boolean wasSprintToggled = Boolean.TRUE.equals(OPTIONS.toggleSprint().get());
+		boolean isSprintToggled = toggleSprint.tick();
+		
+		if (temporarySprintTimer > 0) {
+			stopSprintingAfterReleasingSprintKey = false;
+			waitingForSprintKeyRelease = false;
+			
+			int nextTemporarySprintTimer = temporarySprintTimer - 1;
+			temporarySprintTimer = 0;
+			
+			if (!KEY_SPRINT.isDown() && KEY_FORWARD.isDown()) {
+				temporarySprintTimer = nextTemporarySprintTimer;
+			}
+			else if (sprintMode == SprintMode.TAP_TO_TOGGLE) {
+				stopSprintingAfterReleasingSprintKey = true;
+			}
+		}
+		
+		if (isSprintToggled) {
 			stopSprintingAfterReleasingSprintKey = false;
 			waitingForSprintKeyRelease = false;
 		}
-		else if (wasSprintToggled){
+		else if (wasSprintToggled) {
 			stopSprintingAfterReleasingSprintKey = true;
-			waitingForSprintKeyRelease = false;
+			waitingForSprintKeyRelease = true;
 		}
-		else if (cfg().tapSprintKeyAgainToStopSprinting){
+		else if (sprintMode == SprintMode.TAP_TO_TOGGLE) {
-			if (opts.keySprint.isPressed()){
+			if (KEY_SPRINT.isDown()) {
-				if (!waitingForSprintKeyRelease){
+				if (!waitingForSprintKeyRelease) {
 					waitingForSprintKeyRelease = true;
 					stopSprintingAfterReleasingSprintKey = player.isSprinting();
 				}
 			}
-			else{
+			else {
-				if (player.isSprinting() && !waitingForSprintKeyRelease){
+				if (player.isSprinting() && !waitingForSprintKeyRelease) {
 					stopSprintingAfterReleasingSprintKey = false;
 				}
 				
 				waitingForSprintKeyRelease = false;
 			}
 		}
+		else if (sprintMode == SprintMode.HOLD) {
+			if (KEY_SPRINT.isDown()) {
+				stopSprintingAfterReleasingSprintKey = true;
+			}
+		}
 		
-		if (stopSprintingAfterReleasingSprintKey && !opts.keySprint.isPressed()){
+		if (stopSprintingAfterReleasingSprintKey && !KEY_SPRINT.isDown()) {
 			stopSprintingAfterReleasingSprintKey = false;
+			waitingForSprintKeyRelease = false;
 			player.setSprinting(false);
 		}
 		
 		toggleSneak.tick();
 	}
 	
-	public void afterInputAssignsPressingForward(final KeyboardInput input){
+	public void afterKeyboardInputAssigned(LocalPlayer player) {
-		if (mc().currentScreen == null){
+		if (MINECRAFT.screen == null && toggleWalkForward.tick()) {
-			input.pressingForward |= toggleWalkForward.tick();
+			ClientInput input = player.input;
+			
+			input.keyPresses = new Input(
+				true,
+				input.keyPresses.backward(),
+				input.keyPresses.left(),
+				input.keyPresses.right(),
+				input.keyPresses.jump(),
+				input.keyPresses.shift(),
+				input.keyPresses.sprint()
+			);
 		}
 	}
 	
-	public void afterInputTick(final ClientPlayerEntity player){
+	public void afterInputTick(LocalPlayer player) {
-		if (mc().currentScreen == null && !player.abilities.flying){
+		if (MINECRAFT.screen == null && !player.getAbilities().flying && toggleJump.tick()) {
-			player.input.jumping |= toggleJump.tick();
+			player.input.makeJump();
 		}
 		
-		final float flightSpeed = FlightHelper.getFlightSpeed(player);
+		if (getConfig().resumeSprintingAfterHittingObstacle) {
-		
+			if (wasHittingObstacle != player.horizontalCollision) {
-		if (flightSpeed > 0F){
+				if (!wasHittingObstacle) {
-			player.abilities.setFlySpeed(flightSpeed);
+					wasSprintingBeforeHittingObstacle = player.isSprinting() || KEY_SPRINT.isDown();
-		}
-		
-		if (cfg().resumeSprintingAfterHittingObstacle){
-			if (wasHittingObstacle != player.horizontalCollision){
-				if (!wasHittingObstacle){
-					wasSprintingBeforeHittingObstacle = player.isSprinting() || mc().options.keySprint.isPressed();
 				}
-				else if (wasSprintingBeforeHittingObstacle){
+				else if (wasSprintingBeforeHittingObstacle) {
 					wasSprintingBeforeHittingObstacle = false;
-					player.setSprinting(true);
+					temporarySprintTimer = 10;
 				}
 				
 				// collision also stops when the player lets go of movement keys
 				wasHittingObstacle = player.horizontalCollision;
 			}
 		}
-		else{
+		else {
 			wasHittingObstacle = player.horizontalCollision;
 			wasSprintingBeforeHittingObstacle = false;
 		}
 	}
 	
-	public void afterSuperCall(final ClientPlayerEntity player){
+	public void afterSuperCall(LocalPlayer player) {
-		if (FlightHelper.shouldFlyOnGround(player)){
+		if (FlightHelper.shouldFlyOnGround(player)) {
-			final boolean isSneaking = player.isSneaking();
+			boolean isSneaking = player.isShiftKeyDown();
-			final boolean isOnGround = player.isOnGround();
+			boolean isOnGround = player.onGround();
 			
-			if (!isSneaking){
+			if (!isSneaking) {
 				wasSneakingBeforeTouchingGround = false;
 			}
-			else if (!isOnGround){
+			else if (!isOnGround) {
 				wasSneakingBeforeTouchingGround = true;
 			}
 			
-			if (!isOnGround){
+			if (!isOnGround) {
 				holdingSneakWhileTouchingGround = false;
 			}
-			else{
+			else {
 				boolean cancelLanding = true;
 				
-				if (!wasSneakingBeforeTouchingGround){
+				if (!wasSneakingBeforeTouchingGround) {
-					if (isSneaking){
+					if (isSneaking) {
 						holdingSneakWhileTouchingGround = true;
 					}
-					else if (holdingSneakWhileTouchingGround){
+					else if (holdingSneakWhileTouchingGround) {
-						player.abilities.flying = false;
+						player.getAbilities().flying = false;
-						player.sendAbilitiesUpdate();
+						player.onUpdateAbilities();
 						cancelLanding = false;
 					}
 				}
 				
-				if (cancelLanding){
+				if (cancelLanding) {
 					player.setOnGround(false);
 				}
 			}
 		}
-		else{
+		else {
 			wasSneakingBeforeTouchingGround = false;
 			holdingSneakWhileTouchingGround = false;
 		}
 		
-		if (player.isCreative()){
+		if (FlightHelper.isFlyingCreativeOrSpectator(player)) {
-			if (cfg().keyToggleFlight.wasPressed()){
+			float inertiaMultiplier = getConfig().flightInertiaMultiplier;
-				final boolean isFlying = !player.abilities.flying;
+			
+			if (inertiaMultiplier < 1F) {
+				ClientInput input = player.input;
+				Input keyPresses = input.keyPresses;
+				double inertiaMultiplierSqrt = Math.sqrt(inertiaMultiplier);
 				
-				player.abilities.flying = isFlying;
+				if (!keyPresses.forward() && !keyPresses.backward() && !keyPresses.left() && !keyPresses.right()) {
-				player.sendAbilitiesUpdate();
+					player.setDeltaMovement(player.getDeltaMovement().multiply(inertiaMultiplierSqrt, 1.0, inertiaMultiplierSqrt));
+				}
 				
-				if (isFlying){
+				if (!keyPresses.jump() && !keyPresses.shift()) {
+					player.setDeltaMovement(player.getDeltaMovement().multiply(1.0, inertiaMultiplierSqrt, 1.0));
+				}
+			}
+		}
+		
+		if (player.isCreative()) {
+			if (getConfig().keyToggleFlight.consumeClick()) {
+				boolean isFlying = !player.getAbilities().flying;
+				
+				player.getAbilities().flying = isFlying;
+				player.onUpdateAbilities();
+				
+				if (isFlying) {
 					temporaryFlyOnGroundTimer = 10;
 				}
 			}
 			
-			if (temporaryFlyOnGroundTimer > 0){
+			if (temporaryFlyOnGroundTimer > 0) {
-				if (player.isSneaking()){
+				if (player.isShiftKeyDown()) {
 					temporaryFlyOnGroundTimer = 0;
 				}
-				else{
+				else {
 					--temporaryFlyOnGroundTimer;
 					player.setOnGround(false);
 				}
 			}
 		}
-		else{
+		else {
 			temporaryFlyOnGroundTimer = 0;
 		}
 		
-		if (!cfg().sneakingMovesCameraSmoothly){
+		if (!getConfig().sneakingMovesCameraSmoothly) {
-			final AccessCameraFields camera = (AccessCameraFields)mc().gameRenderer.getCamera();
+			Camera camera = MINECRAFT.gameRenderer.getMainCamera();
 			
-			if (camera.getFocusedEntity() == player){
+			if (camera.getEntity() == player) {
-				camera.setCameraY(player.getStandingEyeHeight());
+				Mixins.cameraFields(camera).setEyeHeight(player.getEyeHeight());
 			}
 		}
 		
-		if (cfg().keyOpenMenu.isPressed()){
+		if (getConfig().keyResetAllToggles.consumeClick()) {
-			mc().openScreen(new BetterControlsScreen(null));
+			toggleSprint.reset();
+			toggleSneak.reset();
+			toggleWalkForward.reset();
+			toggleJump.reset();
+		}
+		
+		if (getConfig().keyOpenMenu.isDown()) {
+			MINECRAFT.setScreen(new BetterControlsScreen(null));
 		}
 	}
+	
+	public static boolean shouldResetFOV(LocalPlayer player) {
+		return getConfig().disableChangingFovWhileFlying && FlightHelper.isFlyingCreativeOrSpectator(player);
+	}
 }

src/main/java/chylex/bettercontrols/player/SprintPressGetter.java

@@ -0,0 +1,10 @@
+package chylex.bettercontrols.player;
+
+import java.util.function.BooleanSupplier;
+
+record SprintPressGetter(BooleanSupplier wrapped, BooleanSupplier or) implements BooleanSupplier {
+	@Override
+	public boolean getAsBoolean() {
+		return wrapped.getAsBoolean() || or.getAsBoolean();
+	}
+}

src/main/java/io/github/prospector/modmenu/api/ConfigScreenFactory.java

@@ -1,8 +0,0 @@
-package io.github.prospector.modmenu.api;
-import net.minecraft.client.gui.screen.Screen;
-
-@SuppressWarnings("unused")
-@FunctionalInterface
-public interface ConfigScreenFactory<S extends Screen>{
-	S create(Screen var1);
-}

src/main/java/io/github/prospector/modmenu/api/ModMenuApi.java

@@ -1,14 +0,0 @@
-package io.github.prospector.modmenu.api;
-import com.google.common.collect.ImmutableMap;
-import java.util.Map;
-
-@SuppressWarnings("unused")
-public interface ModMenuApi{
-	default ConfigScreenFactory<?> getModConfigScreenFactory(){
-		return ignore -> null;
-	}
-	
-	default Map<String, ConfigScreenFactory<?>> getProvidedConfigScreenFactories(){
-		return ImmutableMap.of();
-	}
-}

src/main/resources/assets/bettercontrols/lang/en_us.json

@@ -5,5 +5,6 @@
   "key.bettercontrols.toggle_flight": "Toggle Flight",
   "key.bettercontrols.toggle_forward": "Toggle Walk Forwards",
   "key.bettercontrols.toggle_jump": "Toggle Jump",
+  "key.bettercontrols.reset_all_toggles": "Reset All Toggles",
   "key.bettercontrols.open_menu": "Open Menu"
 }

src/main/resources/bettercontrols.mixins.json

@@ -2,20 +2,25 @@
   "required": true,
   "minVersion": "0.8",
   "package": "chylex.bettercontrols.mixin",
-  "compatibilityLevel": "JAVA_8",
+  "refmap": "bettercontrols.refmap.json",
-  "mixins": [
+  "compatibilityLevel": "JAVA_21",
+  "client": [
     "AccessCameraFields",
     "AccessClientPlayerFields",
-    "AccessControlsListCategory",
+    "AccessKeyMappingFields",
-    "AccessControlsListKeyBinding",
+    "AccessPlayerFields",
-    "AccessKeyBindingFields",
+    "AccessToggleKeyMappingFields",
-    "AccessScreenButtons",
+    "HookClientPlayerFOV",
     "HookClientPlayerInputTick",
     "HookClientPlayerTick",
+    "HookClientPlayerVerticalFlightSpeed",
     "HookControlsListWidget",
+    "HookControlsScreen",
     "HookLoadGameOptions",
-    "HookOpenScreen",
+    "HookPlayerGliding",
-    "HookStickyKeyBindingState"
+    "HookPlayerHorizontalFlightSpeed",
+    "HookStickyKeyBindingState",
+    "HookToggleOptionButtons"
   ],
   "injectors": {
     "defaultRequire": 1

src/main/resources/fabric.mod.json

@@ -1,33 +0,0 @@
-{
-  "schemaVersion": 1,
-  "id": "bettercontrols",
-  "version": "${version}",
-  
-  "name": "Better Controls",
-  "description": "Adds many powerful key bindings and options to control your movement.\nThe features complement vanilla mechanics without giving unfair advantages, so server use should be fine.",
-  "icon": "assets/bettercontrols/icon.png",
-  "license": "MPL-2.0",
-  
-  "authors": [ "chylex" ],
-  "contact": {
-    "homepage": "",
-    "sources": "https://github.com/chylex/Better-Controls",
-    "issues": "https://github.com/chylex/Better-Controls/issues"
-  },
-  
-  "environment": "client",
-  "entrypoints": {
-    "client": [ "chylex.bettercontrols.BetterControlsMod" ],
-    "modmenu": [ "chylex.bettercontrols.compatibility.ModMenuSupport" ]
-  },
-  
-  "mixins": [{
-    "config": "bettercontrols.mixins.json",
-    "environment": "client"
-  }],
-  
-  "depends": {
-    "fabricloader": ">=0.7.4",
-    "minecraft": ">=1.16.2"
-  }
-}

src/main/resources/pack.mcmeta

@@ -0,0 +1,7 @@
+{
+    "pack": {
+        "description": "${name}",
+        "pack_format": 7,
+        "_comment": ""
+    }
+}

src/multiloader/resources/META-INF/jarjar/metadata.json

@@ -0,0 +1,13 @@
+{
+  "jars": [{
+    "identifier": {
+      "group": "${group}",
+      "artifact": "${id}"
+    },
+    "version": {
+      "artifactVersion": "${version}",
+      "range": "[${version}]"
+    },
+    "path": "jars/${jarPrefix}-NeoForge.jar"
+  }]
+}

src/multiloader/resources/fabric.mod.json

@@ -0,0 +1,34 @@
+{
+  "schemaVersion": 1,
+  "id": "${id}_multiloader",
+  "name": "${name} (Multiloader)",
+  "description": "${description}",
+  "version": "${version}",
+  "license": "${license}",
+  
+  "icon": "assets/${id}/logo.png",
+  
+  "authors": [
+    "${author}"
+  ],
+  
+  "contact": {
+    "homepage": "https://chylex.com",
+    "issues": "${issuesURL}",
+    "sources": "${sourcesURL}"
+  },
+  
+  "environment": "${sidesForFabric}",
+  
+  "jars": [{
+      "file": "jars/${jarPrefix}-Fabric.jar"
+  }],
+  
+  "custom": {
+    "modmenu": {
+      "parent": "${id}",
+      "badges": [ "library" ],
+      "update_checker": false
+    }
+  }
+}