Work on a framework to make UI stuff not suck

# Conflicts:
#	common/src/main/kotlin/com/cobblemon/mod/common/client/CobblemonClient.kt
#	common/src/main/kotlin/com/cobblemon/mod/common/client/integration/controlify/CobblemonControlifyEntrypoint.kt
#	common/src/main/kotlin/com/cobblemon/mod/common/client/integration/controlify/gui/InteractWheelProcessor.kt

CHANGELOG.md

@@ -6,6 +6,7 @@
 - Added the Partner Mark, which party Pokémon have a very small chance to earn as the player walks, provided they have enough friendship.
 - Added trades for Saccharine Saplings, Hearty Grains, Chipped Pot, and Masterpiece Teacup to the Wandering Trader.
 - Added brewing recipe for Throat Spray.
+- Added official Controlify Support
 - Added new effects
   - Mental Restoration: Reduces "Time Since Last Rest" statistic, which controls Insomnia, by half a minute per second per effect level
   - Negative Effect Cleanse: Removes all negative effects

common/build.gradle.kts

@@ -32,6 +32,10 @@ repositories {
     maven(url = "https://api.modrinth.com/maven")
     maven(url = "https://maven.neoforged.net/releases")
     maven(url = "https://maven.gegy.dev")
+    exclusiveContent {
+        forRepository { maven(url = "https://maven.isxander.dev/releases") }
+        filter { includeGroup("dev.isxander") }
+    }
     mavenLocal()
 }
 
@@ -62,6 +66,11 @@ dependencies {
 
     // Unit Testing
     testImplementation(libs.bundles.unitTesting)
+
+    // Controlify Compat, same as flywheel so we pick one and only use the api
+    modCompileOnlyApi("dev.isxander:controlify:2.4.3+1.21.1-fabric") {
+        isTransitive = false
+    }
 }
 
 tasks.withType<Test> {

common/src/main/java/com/cobblemon/mod/common/mixin/client/MouseHandlerMixin.java

@@ -21,12 +21,14 @@ import com.llamalad7.mixinextras.injector.v2.WrapWithCondition;
 import com.llamalad7.mixinextras.sugar.Local;
 import com.mojang.blaze3d.Blaze3D;
 import kotlin.Pair;
+import kotlin.jvm.functions.Function4;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.MouseHandler;
 import net.minecraft.client.player.LocalPlayer;
 import net.minecraft.util.Mth;
 import net.minecraft.util.SmoothDouble;
 import net.minecraft.world.phys.Vec3;
+import org.joml.Vector2d;
 import org.objectweb.asm.Opcodes;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
@@ -146,6 +148,12 @@ public abstract class MouseHandlerMixin {
             pokeVehicle.clampPassengerRotation(player);
         }
 
+        for(Function4<LocalPlayer, Double, Double, Double, Vector2d> rideFun : CobblemonClient.INSTANCE.getRidingTurnInputHandler().values()) {
+            Vector2d vec = rideFun.invoke(player, cursorDeltaX, cursorDeltaY, d);
+            cursorDeltaX = vec.x;
+            cursorDeltaY = vec.y;
+        }
+
         // If the ride is not orientation controllable then return and perform the normal turnPlayer logic
         if (!(vehicle instanceof OrientationControllable controllableVehicle) || !controllableVehicle.getOrientationController().isActive()) {
             xMouseSmoother.reset();

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/land/HorseBehaviour.kt

@@ -22,6 +22,7 @@ import com.cobblemon.mod.common.api.riding.posing.PoseOption
 import com.cobblemon.mod.common.api.riding.posing.PoseProvider
 import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.client.CobblemonClient
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.blockPositionsAsListRounded
@@ -144,11 +145,12 @@ class HorseBehaviour : RidingBehaviour<HorseSettings, HorseState> {
     ) {
         val sprintTimerTickLength = 7 // Emulate vanillas tick timer length
         var hasDoubleTapped = false
+        val forward = Minecraft.getInstance().player?.input?.up == true
 
         // If you are not sprinting and you just pressed down and theres no
-        if (!state.forwardHeldLastTick.get() && Minecraft.getInstance().options.keyUp.isDown() && !state.sprinting.get() && state.sprintTickTimer.get() == 0) {
+        if (!state.forwardHeldLastTick.get() && forward && !state.sprinting.get() && state.sprintTickTimer.get() == 0) {
             state.sprintTickTimer.set(sprintTimerTickLength)
-        } else if (!state.forwardHeldLastTick.get() && Minecraft.getInstance().options.keyUp.isDown() && state.sprintTickTimer.get() != 0) { // If has double tapped
+        } else if (!state.forwardHeldLastTick.get() && forward && state.sprintTickTimer.get() != 0) { // If has double tapped
             hasDoubleTapped = true
         }else if(!state.sprinting.get() && state.sprintTickTimer.get() > 0) {
             state.sprintTickTimer.set(state.sprintTickTimer.get() - 1)
@@ -156,9 +158,9 @@ class HorseBehaviour : RidingBehaviour<HorseSettings, HorseState> {
             state.sprintTickTimer.set(0)
         }
 
-        val tryingToSprint = (Minecraft.getInstance().options.keySprint.isDown() && Minecraft.getInstance().options.keyUp.isDown()) || hasDoubleTapped
+        val tryingToSprint = hasDoubleTapped || CobblemonClient.ridingSprintHandler.any { it.value.invoke() }
 
-        if (state.stamina.get() <= 0.0f || !Minecraft.getInstance().options.keyUp.isDown()) {
+        if (state.stamina.get() <= 0.0f || !forward) {
             // If stamina runs out or the player is not holding forward then stop sprinting
             state.sprinting.set(false)
             if (state.stamina.get() <= 0.0f) {
@@ -172,8 +174,8 @@ class HorseBehaviour : RidingBehaviour<HorseSettings, HorseState> {
             state.sprinting.set(true)
         }
 
-        // Take not of whether forward was held last tick
-        state.forwardHeldLastTick.set(Minecraft.getInstance().options.keyUp.isDown())
+        // Take note of whether forward was held last tick
+        state.forwardHeldLastTick.set(forward)
     }
 
     fun tickStamina(

common/src/main/kotlin/com/cobblemon/mod/common/client/CobblemonClient.kt

@@ -74,6 +74,7 @@ import com.cobblemon.mod.common.entity.boat.CobblemonBoatType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.platform.events.PlatformEvents
 import com.cobblemon.mod.common.pokedex.scanner.PokedexUsageContext
+import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.isLookingAt
 import net.minecraft.client.Minecraft
 import net.minecraft.client.color.block.BlockColor
@@ -83,16 +84,19 @@ import net.minecraft.client.gui.screens.Screen
 import net.minecraft.client.model.BoatModel
 import net.minecraft.client.model.ChestBoatModel
 import net.minecraft.client.model.PlayerModel
+import net.minecraft.client.player.LocalPlayer
 import net.minecraft.client.renderer.RenderType
 import net.minecraft.client.renderer.blockentity.HangingSignRenderer
 import net.minecraft.client.renderer.blockentity.SignRenderer
 import net.minecraft.client.renderer.entity.EntityRenderer
 import net.minecraft.client.renderer.entity.LivingEntityRenderer
 import net.minecraft.client.resources.PlayerSkin
+import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.packs.resources.ResourceManager
 import net.minecraft.world.InteractionHand
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.AABB
+import org.joml.Vector2d
 
 object CobblemonClient {
 
@@ -112,6 +116,8 @@ object CobblemonClient {
     val battleOverlay: BattleOverlay by lazy { BattleOverlay() }
     val pokedexUsageContext: PokedexUsageContext by lazy { PokedexUsageContext() }
     val rideControlsOverlay: RideControlsOverlay by lazy { RideControlsOverlay() }
+    val ridingTurnInputHandler: MutableMap<ResourceLocation, (LocalPlayer, Double, Double, Double) -> Vector2d> = mutableMapOf()
+    val ridingSprintHandler: MutableMap<ResourceLocation, () -> Boolean> = mutableMapOf()
 
     fun onLogin() {
         clientPlayerData = ClientGeneralPlayerData()
@@ -195,6 +201,8 @@ object CobblemonClient {
             ClientPlayerIcon.onTick()
             PartyOverlayDataControl.tick(event.client.isPaused)
         }
+
+        ridingSprintHandler.put(cobblemonResource("normal")) { Minecraft.getInstance().options.keySprint.isDown }
     }
 
     private fun registerTooltipManagers() {

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/interact/wheel/InteractWheelButton.kt

@@ -74,12 +74,12 @@ class InteractWheelButton(
             y = y,
             width = width,
             height = height,
-            vOffset = if (isHovered(mouseX.toFloat(), mouseY.toFloat()) && isEnabled) height else 0,
+            vOffset = if ((isHovered(mouseX.toFloat(), mouseY.toFloat()) || isFocused) && isEnabled) height else 0,
             textureHeight = height * 2,
             alpha = if (isEnabled) 1f else 0.4F
         )
 
-        if(isEnabled && isHovered(mouseX.toFloat(), mouseY.toFloat())){
+        if(isEnabled && (isHovered(mouseX.toFloat(), mouseY.toFloat()) || isFocused)){
             tooltipText?.let {
                 context.renderTooltip(Minecraft.getInstance().font, Component.translatable(it), mouseX, mouseY)
             }

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/interact/wheel/InteractWheelGUI.kt

@@ -23,9 +23,9 @@ class InteractWheelGUI(private val options: Multimap<Orientation, InteractWheelO
         private val backgroundResource = cobblemonResource("textures/gui/interact/interact_wheel_base.png")
     }
 
-    private val buttons = mutableListOf<InteractWheelButton>()
-    private var maxPage = 1
-    private var currentPage = 0
+    val buttons = mutableListOf<InteractWheelButton>()
+    var maxPage = 1
+    var currentPage = 0
     override fun renderBlurredBackground(delta: Float) { }
     override fun renderMenuBackground(context: GuiGraphics) {}
 
@@ -77,7 +77,7 @@ class InteractWheelGUI(private val options: Multimap<Orientation, InteractWheelO
         currentPage = page
         buttons.forEach { removeWidget(it) }
         buttons.clear()
-        val orientations = Orientation.values()
+        val orientations = Orientation.entries.toTypedArray()
         orientations.forEach { orientation ->
             val option = options[orientation].toList().getOrNull(page)
             addButton(orientation, option)

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/controlify/CobblemonControlifyEntrypoint.kt

@@ -0,0 +1,319 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.integration.controlify
+
+import com.cobblemon.mod.common.CobblemonItems
+import com.cobblemon.mod.common.OrientationControllable
+import com.cobblemon.mod.common.client.CobblemonClient
+import com.cobblemon.mod.common.client.CobblemonClient.ridingTurnInputHandler
+import com.cobblemon.mod.common.client.gui.battle.BattleGUI
+import com.cobblemon.mod.common.client.gui.behaviour.BehaviourEditorScreen
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen
+import com.cobblemon.mod.common.client.gui.cookingpot.CookingPotScreen
+import com.cobblemon.mod.common.client.gui.debug.riding.RidingStatsDebugGUI
+import com.cobblemon.mod.common.client.gui.dialogue.DialogueScreen
+import com.cobblemon.mod.common.client.gui.interact.battleRequest.BattleConfigureGUI
+import com.cobblemon.mod.common.client.gui.interact.moveselect.MoveSelectGUI
+import com.cobblemon.mod.common.client.gui.interact.partyselect.PartySelectGUI
+import com.cobblemon.mod.common.client.gui.interact.wheel.InteractWheelGUI
+import com.cobblemon.mod.common.client.gui.npc.NPCEditorScreen
+import com.cobblemon.mod.common.client.gui.pc.PCGUI
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUI
+import com.cobblemon.mod.common.client.gui.pokenav.PokeNav
+import com.cobblemon.mod.common.client.gui.snapshots.SnapshotWarningScreen
+import com.cobblemon.mod.common.client.gui.startselection.StarterSelectionScreen
+import com.cobblemon.mod.common.client.gui.summary.Summary
+import com.cobblemon.mod.common.client.gui.trade.TradeGUI
+import com.cobblemon.mod.common.client.integration.controlify.gui.CobblemonGUIProcessor
+import com.cobblemon.mod.common.client.integration.controlify.gui.InteractWheelProcessor
+import com.cobblemon.mod.common.client.keybind.CobblemonKeyBinds
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.cobblemonResource
+import dev.isxander.controlify.api.ControlifyApi
+import dev.isxander.controlify.api.bind.ControlifyBindApi
+import dev.isxander.controlify.api.bind.InputBindingBuilder
+import dev.isxander.controlify.api.bind.InputBindingSupplier
+import dev.isxander.controlify.api.entrypoint.ControlifyEntrypoint
+import dev.isxander.controlify.api.entrypoint.InitContext
+import dev.isxander.controlify.api.entrypoint.PreInitContext
+import dev.isxander.controlify.bindings.BindContext
+import dev.isxander.controlify.bindings.ControlifyBindings
+import dev.isxander.controlify.bindings.RadialIcons
+import dev.isxander.controlify.screenop.ScreenProcessorFactory
+import net.minecraft.client.Minecraft
+import net.minecraft.client.gui.screens.Screen
+import net.minecraft.client.player.LocalPlayer
+import net.minecraft.network.chat.Component
+import net.minecraft.world.item.Items
+import org.joml.Vector2d
+import kotlin.jvm.optionals.getOrNull
+import kotlin.reflect.KClass
+import kotlin.reflect.full.primaryConstructor
+
+class CobblemonControlifyEntrypoint : ControlifyEntrypoint {
+    override fun onControlifyInit(initContext: InitContext) {
+        ridingTurnInputHandler.put(
+            cobblemonResource("compat.controlify"),
+            ({ localPlayer: LocalPlayer, xDelta: Double, yDelta: Double, deltaTime: Double ->
+                val vec = Vector2d(xDelta, yDelta)
+                val controller = initContext.controlify().currentController.getOrNull()
+                val vehicle = localPlayer.vehicle
+                if (vehicle is OrientationControllable && vehicle.orientationController.isActive() && initContext.controlify().currentInputMode().isController && controller != null){
+                    val multiplier = deltaTime * 1500
+                    val config = controller.input().getOrNull()?.config()?.config()
+                    val vSensitivity = config?.vLookSensitivity ?: 0.9f
+                    val hSensitivity = config?.hLookSensitivity ?: 1f
+
+                    // Should never be null once bindings are set
+                    var vAxis = (RIDING_DOWN!!.on(controller).analogueNow() - RIDING_UP!!.on(controller).analogueNow()).toDouble()
+                    var hAxis = (RIDING_RIGHT!!.on(controller).analogueNow() - RIDING_LEFT!!.on(controller).analogueNow()).toDouble()
+
+                    vAxis *= multiplier * vSensitivity
+                    hAxis *= multiplier * hSensitivity
+                    vec.x = hAxis
+                    vec.y = vAxis
+                }
+                vec
+            })
+        )
+
+        CobblemonClient.ridingSprintHandler.put(
+            cobblemonResource("compat.controlify")
+        ) {
+            initContext.controlify().currentController.getOrNull()?.let { ControlifyBindings.SPRINT.on(it).digitalNow() } == true
+        }
+    }
+
+    override fun onControlifyPreInit(initContext: PreInitContext) {
+        val bindings = ControlifyBindApi.get()
+        bindings.registerBindContext(ORIENTATION_CONTROLLER_ACTIVE)
+
+        RIDING_UP =
+            bindings.registerBinding { builder: InputBindingBuilder ->
+                builder
+                    .id(cobblemonResource("riding_up"))
+                    .category(Component.translatable("controlify.category.cobblemon.cobblemon"))
+                    .name(Component.translatable("controlify.bind.cobblemon.riding_up"))
+                    .allowedContexts(ORIENTATION_CONTROLLER_ACTIVE, BindContext.IN_GAME)
+            }
+
+        RIDING_DOWN =
+            bindings.registerBinding { builder: InputBindingBuilder ->
+                builder
+                    .id(cobblemonResource("riding_down"))
+                    .category(Component.translatable("controlify.category.cobblemon.cobblemon"))
+                    .name(Component.translatable("controlify.bind.cobblemon.riding_down"))
+                    .allowedContexts(ORIENTATION_CONTROLLER_ACTIVE, BindContext.IN_GAME)
+            }
+
+        RIDING_LEFT =
+            bindings.registerBinding { builder: InputBindingBuilder ->
+                builder
+                    .id(cobblemonResource("riding_left"))
+                    .category(Component.translatable("controlify.category.cobblemon.cobblemon"))
+                    .name(Component.translatable("controlify.bind.cobblemon.riding_left"))
+                    .allowedContexts(ORIENTATION_CONTROLLER_ACTIVE, BindContext.IN_GAME)
+            }
+
+        RIDING_RIGHT =
+            bindings.registerBinding { builder: InputBindingBuilder ->
+                builder
+                    .id(cobblemonResource("riding_right"))
+                    .category(Component.translatable("controlify.category.cobblemon.cobblemon"))
+                    .name(Component.translatable("controlify.bind.cobblemon.riding_right"))
+                    .allowedContexts(ORIENTATION_CONTROLLER_ACTIVE, BindContext.IN_GAME)
+            }
+
+        HIDE_PARTY =
+            bindings.registerBinding { builder: InputBindingBuilder ->
+                builder
+                    .id(cobblemonResource("hide_party"))
+                    .category(Component.translatable("controlify.category.cobblemon.cobblemon"))
+                    .name(Component.translatable("key.cobblemon.hideparty"))
+                    .allowedContexts(BindContext.IN_GAME)
+                    .radialCandidate(RadialIcons.getItem(Items.BARRIER))
+                    .addKeyCorrelation(CobblemonKeyBinds.HIDE_PARTY)
+                    .keyEmulation(CobblemonKeyBinds.HIDE_PARTY)
+            }
+
+        SUMMARY =
+            bindings.registerBinding { builder: InputBindingBuilder ->
+                builder
+                    .id(cobblemonResource("summary"))
+                    .category(Component.translatable("controlify.category.cobblemon.cobblemon"))
+                    .name(Component.translatable("key.cobblemon.summary"))
+                    .allowedContexts(BindContext.IN_GAME)
+                    .radialCandidate(RadialIcons.getItem(CobblemonItems.GREAT_BALL))
+                    .addKeyCorrelation(CobblemonKeyBinds.SUMMARY)
+                    .keyEmulation(CobblemonKeyBinds.SUMMARY)
+            }
+
+        PARTY_OVERLAY_DOWN =
+            bindings.registerBinding { builder: InputBindingBuilder ->
+                builder
+                    .id(cobblemonResource("party_overlay_down"))
+                    .category(Component.translatable("controlify.category.cobblemon.cobblemon"))
+                    .name(Component.translatable("key.cobblemon.downshiftparty"))
+                    .allowedContexts(HAS_POKEMON, BindContext.IN_GAME)
+                    .radialCandidate(RadialIcons.EMPTY)
+                    .addKeyCorrelation(CobblemonKeyBinds.PARTY_OVERLAY_DOWN)
+                    .keyEmulation(CobblemonKeyBinds.PARTY_OVERLAY_DOWN)
+            }
+
+        PARTY_OVERLAY_UP =
+            bindings.registerBinding { builder: InputBindingBuilder ->
+                builder
+                    .id(cobblemonResource("party_overlay_up"))
+                    .category(Component.translatable("controlify.category.cobblemon.cobblemon"))
+                    .name(Component.translatable("key.cobblemon.upshiftparty"))
+                    .allowedContexts(HAS_POKEMON, BindContext.IN_GAME)
+                    .radialCandidate(RadialIcons.EMPTY)
+                    .addKeyCorrelation(CobblemonKeyBinds.PARTY_OVERLAY_UP)
+                    .keyEmulation(CobblemonKeyBinds.PARTY_OVERLAY_DOWN)
+            }
+
+        SEND_OUT_POKEMON =
+            bindings.registerBinding { builder: InputBindingBuilder ->
+                builder
+                    .id(cobblemonResource("send_out_pokemon"))
+                    .category(Component.translatable("controlify.category.cobblemon.cobblemon"))
+                    .name(Component.translatable("key.cobblemon.throwpartypokemon"))
+                    .allowedContexts(HAS_POKEMON, BindContext.IN_GAME)
+                    .radialCandidate(RadialIcons.getItem(CobblemonItems.POKE_BALL))
+                    .addKeyCorrelation(CobblemonKeyBinds.SEND_OUT_POKEMON)
+                    .keyEmulation(CobblemonKeyBinds.SEND_OUT_POKEMON)
+            }
+
+
+        RIDING_FREELOOK =
+            bindings.registerBinding { builder: InputBindingBuilder ->
+                builder
+                    .id(cobblemonResource("riding_freelook"))
+                    .category(Component.translatable("controlify.category.cobblemon.cobblemon"))
+                    .name(Component.translatable("key.cobblemon.ridingfreelook"))
+                    .allowedContexts(RIDING_POKEMON, BindContext.IN_GAME)
+                    .radialCandidate(RadialIcons.EMPTY)
+                    .addKeyCorrelation(CobblemonKeyBinds.RIDING_FREELOOK)
+                    .keyEmulation(CobblemonKeyBinds.RIDING_FREELOOK)
+            }
+
+        INTERACT_WHEEL_UP_AXIS =
+            bindings.registerBinding { builder: InputBindingBuilder ->
+                builder
+                    .id(cobblemonResource("interact_wheel_up"))
+                    .category(Component.translatable("controlify.category.cobblemon.cobblemon"))
+                    .name(Component.translatable("controlify.bind.cobblemon.interact_wheel_up"))
+                    .allowedContexts(INTERACT_WHEEL_SCREEN, BindContext.IN_GAME)
+            }
+
+        INTERACT_WHEEL_DOWN_AXIS =
+            bindings.registerBinding { builder: InputBindingBuilder ->
+                builder
+                    .id(cobblemonResource("interact_wheel_down"))
+                    .category(Component.translatable("controlify.category.cobblemon.cobblemon"))
+                    .name(Component.translatable("controlify.bind.cobblemon.interact_wheel_down"))
+                    .allowedContexts(INTERACT_WHEEL_SCREEN, BindContext.IN_GAME)
+            }
+
+        INTERACT_WHEEL_RIGHT_AXIS =
+            bindings.registerBinding { builder: InputBindingBuilder ->
+                builder
+                    .id(cobblemonResource("interact_wheel_right"))
+                    .category(Component.translatable("controlify.category.cobblemon.cobblemon"))
+                    .name(Component.translatable("controlify.bind.cobblemon.interact_wheel_right"))
+                    .allowedContexts(INTERACT_WHEEL_SCREEN, BindContext.IN_GAME)
+            }
+
+        INTERACT_WHEEL_LEFT_AXIS =
+            bindings.registerBinding { builder: InputBindingBuilder ->
+                builder
+                    .id(cobblemonResource("interact_wheel_left"))
+                    .category(Component.translatable("controlify.category.cobblemon.cobblemon"))
+                    .name(Component.translatable("controlify.bind.cobblemon.interact_wheel_left"))
+                    .allowedContexts(INTERACT_WHEEL_SCREEN, BindContext.IN_GAME)
+            }
+
+
+        addProcessor(InteractWheelGUI::class, InteractWheelProcessor::class)
+        // This is the lazy way to do all of these (just using the vmouse), if someone with more time and dedication did this that would be better
+        addProcessor(BattleGUI::class, CobblemonGUIProcessor::class)
+        addProcessor(BehaviourEditorScreen::class, CobblemonGUIProcessor::class)
+        addProcessor(CobblemonConfigScreen::class, CobblemonGUIProcessor::class)
+        addProcessor(CookingPotScreen::class, CobblemonGUIProcessor::class)
+        addProcessor(RidingStatsDebugGUI::class, CobblemonGUIProcessor::class)
+        addProcessor(DialogueScreen::class, CobblemonGUIProcessor::class)
+        addProcessor(BattleConfigureGUI::class, CobblemonGUIProcessor::class)
+        addProcessor(MoveSelectGUI::class, CobblemonGUIProcessor::class)
+        addProcessor(PartySelectGUI::class, CobblemonGUIProcessor::class)
+        addProcessor(NPCEditorScreen::class, CobblemonGUIProcessor::class)
+        addProcessor(PCGUI::class, CobblemonGUIProcessor::class)
+        addProcessor(PokedexGUI::class, CobblemonGUIProcessor::class)
+        addProcessor(PokeNav::class, CobblemonGUIProcessor::class)
+        addProcessor(SnapshotWarningScreen::class, CobblemonGUIProcessor::class)
+        addProcessor(StarterSelectionScreen::class, CobblemonGUIProcessor::class)
+        addProcessor(Summary::class, CobblemonGUIProcessor::class)
+        addProcessor(TradeGUI::class, CobblemonGUIProcessor::class)
+    }
+
+    override fun onControllersDiscovered(controlifyApi: ControlifyApi) {
+    }
+
+    // This is jank, but I did it after I got my wisdom teeth extracted so tbh I think I did good enough, but I won't be offended if someone changes it to something sane.
+    fun addProcessor(t: KClass<out Screen>, processorClazz: KClass<out CobblemonGUIProcessor>) {
+        ScreenProcessorFactory.registerProvider(t.java) {
+            processorClazz.primaryConstructor?.call(it)
+        }
+    }
+
+    companion object {
+        var RIDING_UP: InputBindingSupplier? = null
+        var RIDING_DOWN: InputBindingSupplier? = null
+        var RIDING_RIGHT: InputBindingSupplier? = null
+        var RIDING_LEFT: InputBindingSupplier? = null
+        var HIDE_PARTY: InputBindingSupplier? = null
+        var SUMMARY: InputBindingSupplier? = null
+        var PARTY_OVERLAY_DOWN: InputBindingSupplier? = null
+        var PARTY_OVERLAY_UP: InputBindingSupplier? = null
+        var SEND_OUT_POKEMON: InputBindingSupplier? = null
+        var RIDING_FREELOOK: InputBindingSupplier? = null
+        var INTERACT_WHEEL_UP_AXIS: InputBindingSupplier? = null
+        var INTERACT_WHEEL_DOWN_AXIS: InputBindingSupplier? = null
+        var INTERACT_WHEEL_LEFT_AXIS: InputBindingSupplier? = null
+        var INTERACT_WHEEL_RIGHT_AXIS: InputBindingSupplier? = null
+
+        val RIDING_POKEMON: BindContext = BindContext(
+            cobblemonResource("riding"),
+            { mc: Minecraft ->
+                mc.player?.vehicle is PokemonEntity
+            }
+        )
+
+        val ORIENTATION_CONTROLLER_ACTIVE: BindContext = BindContext(
+            cobblemonResource("orientation_controller_active"),
+            { mc: Minecraft ->
+                val localPlayer = mc.player
+                if (localPlayer == null) return@BindContext false
+                val vehicle = localPlayer.vehicle
+                vehicle is OrientationControllable && vehicle.getOrientationController().isActive()
+            }
+        )
+
+        val HAS_POKEMON: BindContext = BindContext(
+            cobblemonResource("has_pokemon"),
+            {mc: Minecraft ->
+                !CobblemonClient.storage.party.isEmpty()
+            }
+        )
+
+        val INTERACT_WHEEL_SCREEN: BindContext = BindContext(
+            cobblemonResource("wheel_screen"),
+            { it.screen is InteractWheelGUI}
+        )
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/controlify/gui/CobblemonGUIProcessor.kt

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.integration.controlify.gui
+
+import com.cobblemon.mod.common.client.integration.controlify.gui.component.ControllerComponentManager
+import dev.isxander.controlify.screenop.ScreenProcessor
+import dev.isxander.controlify.virtualmouse.VirtualMouseBehaviour
+import net.minecraft.client.gui.screens.Screen
+
+open class CobblemonGUIProcessor(open val screen: Screen) : ScreenProcessor<Screen>(screen) {
+    val controllerComponentManager = ControllerComponentManager(screen)
+
+    override fun virtualMouseBehaviour(): VirtualMouseBehaviour {
+        return VirtualMouseBehaviour.DISABLED
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/controlify/gui/InteractWheelProcessor.kt

@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.integration.controlify.gui
+
+import com.cobblemon.mod.common.client.gui.interact.wheel.InteractWheelGUI
+import com.cobblemon.mod.common.client.integration.controlify.CobblemonControlifyEntrypoint
+import dev.isxander.controlify.controller.ControllerEntity
+import dev.isxander.controlify.controller.haptic.HapticEffects
+import dev.isxander.controlify.screenop.ScreenControllerEventListener
+import net.minecraft.util.Mth
+import kotlin.math.abs
+
+
+// Lots of this is taken from the RadialMenu in Controlify to make this screen feel consistent with it
+class InteractWheelProcessor(override val screen: InteractWheelGUI) : CobblemonGUIProcessor(screen), ScreenControllerEventListener {
+    private var selectedButton = -1
+    private var idleTicks: Int = 0
+    private var idleTicksTimeout: Int? = null
+
+    init {
+        addEventListener(this)
+    }
+
+    override fun onControllerInput(controller: ControllerEntity) {
+        if (idleTicksTimeout == null) {
+            idleTicksTimeout = controller.input().orElseThrow().confObj().radialButtonFocusTimeoutTicks
+        }
+
+        // If not created from entrypoint then something is very wrong
+        val x = CobblemonControlifyEntrypoint.INTERACT_WHEEL_RIGHT_AXIS!!.on(controller).analogueNow()
+                - CobblemonControlifyEntrypoint.INTERACT_WHEEL_LEFT_AXIS!!.on(controller).analogueNow()
+        val y = CobblemonControlifyEntrypoint.INTERACT_WHEEL_DOWN_AXIS!!.on(controller).analogueNow()
+                - CobblemonControlifyEntrypoint.INTERACT_WHEEL_UP_AXIS!!.on(controller).analogueNow()
+        val threshold = controller.input().orElseThrow().config().config().buttonActivationThreshold
+
+        if (abs(x) >= threshold || abs(y) >= threshold) {
+            val angle = Mth.wrapDegrees(Mth.RAD_TO_DEG * Mth.atan2(y.toDouble(), x.toDouble()) - 90f) + 180f
+            val buttonCount = screen.buttons.size
+            val each = 360f / buttonCount
+
+            val newSelected = Mth.floor((angle + each / 2f) / each) % buttonCount
+            if (newSelected != selectedButton) {
+                selectedButton = newSelected
+                controller.hdHaptics().ifPresent { haptics -> haptics.playHaptic(HapticEffects.NAVIGATE) }
+            }
+
+            for (button in 0..<buttonCount) {
+                val selected = button == selectedButton
+                screen.buttons[button].isFocused = selected
+            }
+
+            idleTicks = 0
+        } else {
+            idleTicks = idleTicks+ 1
+            if (idleTicks>= idleTicksTimeout!! && selectedButton != -1) {
+                selectedButton = -1
+                for (button in screen.buttons) {
+                    button.isFocused = false
+                }
+                controller.hdHaptics().ifPresent { haptics -> haptics.playHaptic(HapticEffects.NAVIGATE) }
+            }
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/controlify/gui/component/ControllerComponent.kt

@@ -0,0 +1,33 @@
+package com.cobblemon.mod.common.client.integration.controlify.gui.component
+
+import net.minecraft.client.gui.components.events.GuiEventListener
+import net.minecraft.client.gui.screens.Screen
+
+class ControllerComponent<T : Screen> {
+    var left: (T) -> ControllerComponent<T>? = { null }
+    var right: (T) -> ControllerComponent<T>? = { null }
+    var up: (T) -> ControllerComponent<T>? = { null }
+    var down: (T) -> ControllerComponent<T>? = { null }
+
+    var associatedGUIElement: GuiEventListener? = null
+
+    fun pairLeft(leftComponent: ControllerComponent<T>) {
+        left = { leftComponent }
+        leftComponent.right = { this }
+    }
+
+    fun pairRight(rightComponent: ControllerComponent<T>) {
+        right = { rightComponent }
+        rightComponent.left = { this }
+    }
+
+    fun pairUp(upComponent: ControllerComponent<T>) {
+        up = { upComponent }
+        upComponent.down = { this }
+    }
+
+    fun pairDown(downComponent: ControllerComponent<T>) {
+        down = { downComponent }
+        downComponent.up = { this }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/controlify/gui/component/ControllerComponentManager.kt

@@ -0,0 +1,17 @@
+package com.cobblemon.mod.common.client.integration.controlify.gui.component
+
+import net.minecraft.client.gui.screens.Screen
+
+class ControllerComponentManager<T : Screen>(val screen: T) {
+    var focused: ControllerComponent<T>?
+        get() = focused
+        set(value) {
+            focused = value
+            focused?.associatedGUIElement?.let { screen.focused = it }
+        }
+
+    fun left() = focused?.left?.invoke(screen)?.let { focused = it }
+    fun right() = focused?.right?.invoke(screen)?.let { focused = it }
+    fun up() = focused?.up?.invoke(screen)?.let { focused = it }
+    fun down() = focused?.down?.invoke(screen)?.let { focused = it }
+}

common/src/main/resources/assets/cobblemon/lang/en_us.json

@@ -9457,5 +9457,11 @@
   "stat.cobblemon.reel_ins": "PokéRod Catches",
   "stat.cobblemon.riding_land": "Distance by Pokémon on Land",
   "stat.cobblemon.riding_air": "Distance by Pokémon in Air",
-  "stat.cobblemon.riding_liquid": "Distance by Pokémon in Liquid"
+  "stat.cobblemon.riding_liquid": "Distance by Pokémon in Liquid",
+
+  "controlify.category.cobblemon.cobblemon": "Cobblemon",
+  "controlify.bind.cobblemon.riding_up": "Look Up",
+  "controlify.bind.cobblemon.riding_down": "Look Down",
+  "controlify.bind.cobblemon.riding_left": "Look Left",
+  "controlify.bind.cobblemon.riding_right": "Look Right"
 }

common/src/main/resources/assets/controlify/controllers/default_bind/default.json

@@ -0,0 +1,28 @@
+{
+  "defaults": {
+    "cobblemon:riding_up": {
+      "axis": "controlify:axis/right_stick_up"
+    },
+    "cobblemon:riding_down": {
+      "axis": "controlify:axis/right_stick_down"
+    },
+    "cobblemon:riding_left": {
+      "axis": "controlify:axis/right_stick_left"
+    },
+    "cobblemon:riding_right": {
+      "axis": "controlify:axis/right_stick_right"
+    },
+    "cobblemon:interact_wheel_up": {
+      "axis": "controlify:axis/right_stick_up"
+    },
+    "cobblemon:interact_wheel_down": {
+      "axis": "controlify:axis/right_stick_down"
+    },
+    "cobblemon:interact_wheel_left": {
+      "axis": "controlify:axis/right_stick_left"
+    },
+    "cobblemon:interact_wheel_right": {
+      "axis": "controlify:axis/right_stick_right"
+    }
+  }
+}

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

@@ -30,6 +30,9 @@
     ],
     "modmenu": [
       "com.cobblemon.mod.fabric.client.integration.modmenu.CobblemonModMenu"
+    ],
+    "controlify": [
+      "com.cobblemon.mod.common.client.integration.controlify.CobblemonControlifyEntrypoint"
     ]
   },
   "mixins": [

neoforge/src/main/resources/META-INF/services/dev.isxander.controlify.api.entrypoint.ControlifyEntrypoint

@@ -0,0 +1 @@
+com.cobblemon.mod.common.client.integration.controlify.CobblemonControlifyEntrypoint