Only cursor aim players may set or clear a node's cursor

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YVREx3uo7nz1FEhzveWTUh

src/main/java/dev/lumareth/improvedAerodynamics/ConfigCommands.java

@@ -5,6 +5,7 @@ import com.mojang.brigadier.arguments.BoolArgumentType;
 import com.mojang.brigadier.arguments.DoubleArgumentType;
 import com.mojang.brigadier.builder.LiteralArgumentBuilder;
 import com.mojang.brigadier.tree.LiteralCommandNode;
+import dev.lumareth.improvedAerodynamics.flight.ControlMode;
 import net.minecraft.commands.CommandSourceStack;
 import net.minecraft.commands.Commands;
 import net.minecraft.network.chat.Component;
@@ -18,7 +19,8 @@ import java.util.List;
 /**
  * /improvedaerodynamics (or /aero) to read and change the most important server config values in game.
  * {@code /aero} lists them, {@code /aero <option>} shows one, {@code /aero <option> <value>} sets and saves it.
- * Needs operator rights, except for the owner of a singleplayer world, who may use them without cheats.
+ * The config options need operator rights, except for the owner of a singleplayer world, who may use them without cheats.
+ * {@code /aero controls keyboard|cursor_aim} is open to every player and picks how they fly.
  * All of them are read live, so changes apply immediately.
  */
 public final class ConfigCommands {
@@ -60,19 +62,45 @@ public final class ConfigCommands {
 
     @SubscribeEvent
     public static void onRegisterCommands(RegisterCommandsEvent event) {
+        // The root is open to everybody for /aero controls, the config options check for rights themselves
         LiteralArgumentBuilder<CommandSourceStack> root = Commands.literal("improvedaerodynamics")
-                .requires(ConfigCommands::mayUse)
+                .executes(context -> mayUse(context.getSource()) ? list(context.getSource()) : denied(context.getSource()));
-                .executes(context -> list(context.getSource()));
         for (Option<?> option : OPTIONS) {
-            root.then(optionNode(option));
+            root.then(optionNode(option).requires(ConfigCommands::mayUse));
         }
+        root.then(controlsNode());
         LiteralCommandNode<CommandSourceStack> node = event.getDispatcher().register(root);
         event.getDispatcher().register(Commands.literal("aero")
-                .requires(ConfigCommands::mayUse)
+                .executes(context -> mayUse(context.getSource()) ? list(context.getSource()) : denied(context.getSource()))
-                .executes(context -> list(context.getSource()))
                 .redirect(node));
     }
 
+    private static int denied(CommandSourceStack source) {
+        source.sendFailure(Component.literal("Use /aero controls keyboard or /aero controls cursor_aim"));
+        return 0;
+    }
+
+    /** /aero controls [keyboard|cursor_aim], for every player (permission level 0). */
+    private static LiteralArgumentBuilder<CommandSourceStack> controlsNode() {
+        return Commands.literal("controls")
+                .requires(source -> source.getEntity() instanceof ServerPlayer)
+                .executes(context -> {
+                    ServerPlayer player = context.getSource().getPlayerOrException();
+                    boolean cursorAim = ControlMode.isCursorAim(player);
+                    context.getSource().sendSuccess(() -> Component.literal("Controls: " + (cursorAim ? "cursor_aim" : "keyboard")), false);
+                    return 1;
+                })
+                .then(Commands.literal("keyboard").executes(context -> setControls(context.getSource(), false)))
+                .then(Commands.literal("cursor_aim").executes(context -> setControls(context.getSource(), true)));
+    }
+
+    private static int setControls(CommandSourceStack source, boolean cursorAim) throws com.mojang.brigadier.exceptions.CommandSyntaxException {
+        ServerPlayer player = source.getPlayerOrException();
+        ControlMode.set(player, cursorAim);
+        source.sendSuccess(() -> Component.literal("Controls set to " + (cursorAim ? "cursor_aim" : "keyboard")), false);
+        return 1;
+    }
+
     private static <T> LiteralArgumentBuilder<CommandSourceStack> optionNode(Option<T> option) {
         return Commands.literal(option.name())
                 .executes(context -> {

src/main/java/dev/lumareth/improvedAerodynamics/ImprovedAerodynamics.java

@@ -1,6 +1,9 @@
 package dev.lumareth.improvedAerodynamics;
 
 import com.mojang.logging.LogUtils;
+import dev.lumareth.improvedAerodynamics.client.aim.CursorAimClientConfig;
+import dev.lumareth.improvedAerodynamics.client.pipper.PipperConfig;
+import dev.lumareth.improvedAerodynamics.flight.CursorAimConfig;
 import dev.lumareth.improvedAerodynamics.flight.PhysicsBridge;
 import dev.lumareth.improvedAerodynamics.network.Network;
 import dev.lumareth.improvedAerodynamics.terrain.LookaheadLoader;
@@ -20,7 +23,11 @@ public class ImprovedAerodynamics {
         MinecraftForge.EVENT_BUS.register(LookaheadLoader.class);
         MinecraftForge.EVENT_BUS.register(PhysicsBridge.class);
         MinecraftForge.EVENT_BUS.register(ConfigCommands.class);
+        MinecraftForge.EVENT_BUS.register(dev.lumareth.improvedAerodynamics.flight.ControlMode.class);
         ModLoadingContext.get().registerConfig(ModConfig.Type.SERVER, Config.SPEC);
+        ModLoadingContext.get().registerConfig(ModConfig.Type.CLIENT, PipperConfig.SPEC);
+        ModLoadingContext.get().registerConfig(ModConfig.Type.SERVER, CursorAimConfig.SPEC, "improved_aerodynamics-cursor-aim.toml");
+        ModLoadingContext.get().registerConfig(ModConfig.Type.CLIENT, CursorAimClientConfig.SPEC, "improved_aerodynamics-cursor-aim-client.toml");
         Network.register();
     }
 }

src/main/java/dev/lumareth/improvedAerodynamics/client/aim/AimKeys.java

@@ -0,0 +1,31 @@
+package dev.lumareth.improvedAerodynamics.client.aim;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import dev.lumareth.improvedAerodynamics.ImprovedAerodynamics;
+import net.minecraft.client.KeyMapping;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.client.event.RegisterKeyMappingsEvent;
+import net.minecraftforge.client.settings.KeyConflictContext;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.common.Mod;
+import org.lwjgl.glfw.GLFW;
+
+/** Keys of cursor aim, which is switched on with /aero controls cursor_aim. The free look key is not shift: in a seat, shift gets the player out of it. */
+public final class AimKeys {
+    public static final KeyMapping FREE_LOOK = new KeyMapping("key.improved_aerodynamics.cursor_aim_free_look",
+            KeyConflictContext.IN_GAME, InputConstants.Type.KEYSYM, GLFW.GLFW_KEY_LEFT_ALT, "key.categories.improved_aerodynamics");
+
+    private AimKeys() {
+    }
+
+    @Mod.EventBusSubscriber(modid = ImprovedAerodynamics.MOD_ID, value = Dist.CLIENT, bus = Mod.EventBusSubscriber.Bus.MOD)
+    public static final class Registration {
+        private Registration() {
+        }
+
+        @SubscribeEvent
+        public static void onRegisterKeyMappings(RegisterKeyMappingsEvent event) {
+            event.register(FREE_LOOK);
+        }
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/client/aim/AimSeat.java

@@ -0,0 +1,15 @@
+package dev.lumareth.improvedAerodynamics.client.aim;
+
+import net.mcreator.valkyrienwarium.entity.SeatEntityEntity;
+import net.minecraft.world.entity.Entity;
+
+/** Everything that touches Warium VS classes, so nothing else loads them when Warium is missing. */
+final class AimSeat {
+    private AimSeat() {
+    }
+
+    static Entity seatOf(Entity rider) {
+        Entity root = rider.getRootVehicle();
+        return root instanceof SeatEntityEntity ? root : null;
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/client/aim/CursorAimClient.java

@@ -0,0 +1,451 @@
+package dev.lumareth.improvedAerodynamics.client.aim;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.BufferBuilder;
+import com.mojang.blaze3d.vertex.BufferUploader;
+import com.mojang.blaze3d.vertex.DefaultVertexFormat;
+import com.mojang.blaze3d.vertex.Tesselator;
+import com.mojang.blaze3d.vertex.VertexFormat;
+import dev.lumareth.improvedAerodynamics.ImprovedAerodynamics;
+import dev.lumareth.improvedAerodynamics.client.pipper.GunPipperRenderer;
+import dev.lumareth.improvedAerodynamics.flight.AimBasis;
+import dev.lumareth.improvedAerodynamics.network.AimPacket;
+import dev.lumareth.improvedAerodynamics.network.Network;
+import net.minecraft.client.Camera;
+import net.minecraft.client.CameraType;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.player.LocalPlayer;
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
+import net.minecraft.util.Mth;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.phys.Vec3;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.client.event.InputEvent;
+import net.minecraftforge.client.event.RenderLevelStageEvent;
+import net.minecraftforge.client.event.ViewportEvent;
+import net.minecraftforge.event.TickEvent;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.ModList;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.util.ObfuscationReflectionHelper;
+import org.joml.Matrix4f;
+import org.joml.Quaterniondc;
+import org.joml.Vector3d;
+import org.joml.Vector3f;
+import org.valkyrienskies.core.api.ships.ClientShip;
+import org.valkyrienskies.core.api.ships.Ship;
+import org.valkyrienskies.mod.common.VSGameUtilsKt;
+
+import java.lang.reflect.Method;
+
+/**
+ * Cursor aim, the client side. While it is on:
+ * <ul>
+ *   <li>the mouse moves a cursor instead of the camera. The cursor is a direction relative to the gun reticle (the
+ *   craft's boresight), at most {@code maxCursorAngleDegrees} away from it, and springs back to it when the mouse
+ *   rests. It is sent to the server every tick, where a virtual pilot flies the craft by it;</li>
+ *   <li>the camera is a chase view, looking along the reticle, or, with look ahead, towards the cursor;</li>
+ *   <li>holding the free look key moves the camera instead of the cursor, it eases back when released;</li>
+ *   <li>the mouse wheel changes how far the camera is behind the craft.</li>
+ * </ul>
+ * The camera is driven through the rotation of the player, which for a rider of a Valkyrien Skies ship is relative to
+ * the ship, so the camera follows the ship's attitude like Valkyrien Skies does for any mounted player. Mouse
+ * movement shows up as a change of that rotation, which is taken as the movement of the cursor and put back.
+ */
+@Mod.EventBusSubscriber(modid = ImprovedAerodynamics.MOD_ID, value = Dist.CLIENT)
+public final class CursorAimClient {
+    private static final int CURSOR_COLOR = 0xFFFFE040;
+    private static final int RETICLE_COLOR = 0xFFFFFFFF;
+    private static final float MARKER_DISTANCE = 2.0F;
+    private static final double LOOK_AHEAD_RATE = 6.0;
+    private static final double FREE_LOOK_RETURN_RATE = 10.0;
+
+    private static boolean active;
+    // Chosen with /aero controls, told by the server
+    private static boolean cursorAimMode;
+    // Cursor as components along the craft's forward (gun reticle), right and up axes
+    private static double cf = 1.0;
+    private static double cr;
+    private static double cu;
+    // Camera direction in ship space and the free look offset on top of it, degrees
+    private static double[] cameraDirection;
+    private static double offsetYaw;
+    private static double offsetPitch;
+    // Rotation the player was given last frame, to see what the mouse did since
+    private static boolean haveLast;
+    private static float lastYaw;
+    private static float lastPitch;
+    private static long lastNanos;
+    private static double zoom;
+    private static CameraType previousCamera;
+    private static Method cameraMove;
+
+    private CursorAimClient() {
+    }
+
+    // ---- Toggling and the packet to the server ----
+
+    @SubscribeEvent
+    public static void onClientTick(TickEvent.ClientTickEvent event) {
+        if (event.phase != TickEvent.Phase.END) {
+            return;
+        }
+        Minecraft minecraft = Minecraft.getInstance();
+        LocalPlayer player = minecraft.player;
+        if (!active) {
+            if (cursorAimMode && player != null && seated(player) && serverHasMod(minecraft)) {
+                activate(minecraft, player);
+            }
+            return;
+        }
+        if (!cursorAimMode) {
+            deactivate(minecraft);
+            return;
+        }
+        if (player == null || !seated(player)) {
+            deactivate(minecraft);
+            return;
+        }
+        send(minecraft, true);
+    }
+
+    /** Called when the server tells the client how its player flies. */
+    public static void setMode(boolean cursorAim) {
+        cursorAimMode = cursorAim;
+    }
+
+    private static boolean seated(LocalPlayer player) {
+        return ModList.get().isLoaded("valkyrien_warium") && AimSeat.seatOf(player) != null;
+    }
+
+    private static boolean serverHasMod(Minecraft minecraft) {
+        return minecraft.getConnection() != null && Network.CHANNEL.isRemotePresent(minecraft.getConnection().getConnection());
+    }
+
+    private static void activate(Minecraft minecraft, LocalPlayer player) {
+        if (!seated(player)) {
+            player.displayClientMessage(Component.translatable("message.improved_aerodynamics.cursor_aim.no_seat"), true);
+            return;
+        }
+        if (!serverHasMod(minecraft)) {
+            player.displayClientMessage(Component.translatable("message.improved_aerodynamics.cursor_aim.no_server"), true);
+            return;
+        }
+        active = true;
+        cf = 1.0;
+        cr = 0.0;
+        cu = 0.0;
+        cameraDirection = null;
+        offsetYaw = 0.0;
+        offsetPitch = 0.0;
+        haveLast = false;
+        lastNanos = System.nanoTime();
+        previousCamera = minecraft.options.getCameraType();
+        minecraft.options.setCameraType(CameraType.THIRD_PERSON_BACK);
+        player.displayClientMessage(Component.translatable("message.improved_aerodynamics.cursor_aim.on"), true);
+    }
+
+    private static void deactivate(Minecraft minecraft) {
+        if (!active) {
+            return;
+        }
+        active = false;
+        send(minecraft, false);
+        if (previousCamera != null) {
+            minecraft.options.setCameraType(previousCamera);
+            previousCamera = null;
+        }
+        if (minecraft.player != null) {
+            minecraft.player.displayClientMessage(Component.translatable("message.improved_aerodynamics.cursor_aim.off"), true);
+        }
+    }
+
+    private static void send(Minecraft minecraft, boolean on) {
+        if (serverHasMod(minecraft)) {
+            Network.CHANNEL.sendToServer(new AimPacket(on, (float) cf, (float) cr, (float) cu));
+        }
+    }
+
+    // ---- Mouse and camera, once per frame before the world is rendered ----
+
+    @SubscribeEvent
+    public static void onRenderTick(TickEvent.RenderTickEvent event) {
+        if (!active || event.phase != TickEvent.Phase.START) {
+            return;
+        }
+        Minecraft minecraft = Minecraft.getInstance();
+        LocalPlayer player = minecraft.player;
+        ClientLevel level = minecraft.level;
+        if (player == null || level == null || !seated(player)) {
+            return;
+        }
+        Entity seat = AimSeat.seatOf(player);
+        AimBasis basis = AimBasis.of(level, seat.blockPosition());
+        if (basis == null) {
+            return;
+        }
+        if (minecraft.options.getCameraType() != CameraType.THIRD_PERSON_BACK) {
+            minecraft.options.setCameraType(CameraType.THIRD_PERSON_BACK);
+        }
+
+        long now = System.nanoTime();
+        double dt = Mth.clamp((now - lastNanos) / 1.0E9, 0.0, 0.1);
+        lastNanos = now;
+
+        // What the mouse did: the player's rotation moved away from what it was set to
+        double deltaYaw = 0.0;
+        double deltaPitch = 0.0;
+        if (haveLast && minecraft.screen == null) {
+            deltaYaw = Mth.wrapDegrees(player.getYRot() - lastYaw);
+            deltaPitch = player.getXRot() - lastPitch;
+            if (Math.abs(deltaYaw) > 90.0 || Math.abs(deltaPitch) > 90.0) {
+                // Not the mouse, something reset the rotation
+                deltaYaw = 0.0;
+                deltaPitch = 0.0;
+            }
+        }
+        double sensitivity = CursorAimClientConfig.MOUSE_SENSITIVITY.get();
+        boolean freeLook = minecraft.screen == null && AimKeys.FREE_LOOK.isDown();
+
+        double spring = CursorAimClientConfig.SPRING_BACK_SECONDS.get();
+        if (spring > 0.0) {
+            shrinkCursor(Math.exp(-dt / spring));
+        }
+        if (freeLook) {
+            offsetYaw += deltaYaw * sensitivity;
+            offsetPitch = Mth.clamp(offsetPitch - deltaPitch * sensitivity, -89.0, 89.0);
+        } else {
+            moveCursor(Math.toRadians(deltaYaw * sensitivity), Math.toRadians(-deltaPitch * sensitivity));
+            double decay = Math.exp(-dt * FREE_LOOK_RETURN_RATE);
+            offsetYaw *= decay;
+            offsetPitch *= decay;
+        }
+
+        // Camera: along the reticle, or turned towards the cursor by the look ahead setting
+        double lookAhead = CursorAimClientConfig.LOOK_AHEAD.get();
+        double[] forward = basis.forward();
+        if (cameraDirection == null || lookAhead <= 0.0) {
+            cameraDirection = forward.clone();
+        } else {
+            double[] target = basis.toShip(cf, cr, cu);
+            cameraDirection = turnTowards(cameraDirection, target, 1.0 - Math.exp(-lookAhead * LOOK_AHEAD_RATE * dt));
+        }
+        double[] direction = rotate(cameraDirection, basis.up(), -Math.toRadians(offsetYaw));
+        direction = rotate(direction, rotate(basis.right(), basis.up(), -Math.toRadians(offsetYaw)), Math.toRadians(offsetPitch));
+
+        // Valkyrien Skies reads the view of a mounted player in ship space: yaw 0 looks along +Z
+        float yaw = (float) Math.toDegrees(Math.atan2(-direction[0], direction[2]));
+        float pitch = (float) Math.toDegrees(Math.atan2(-direction[1], Math.hypot(direction[0], direction[2])));
+        player.setYRot(yaw);
+        player.setXRot(pitch);
+        player.yRotO = yaw;
+        player.xRotO = pitch;
+        player.yHeadRot = yaw;
+        player.yHeadRotO = yaw;
+        lastYaw = yaw;
+        lastPitch = pitch;
+        haveLast = true;
+    }
+
+    /** Moves the cursor like a look direction: yaw towards the right, pitch up, radians. */
+    private static void moveCursor(double yaw, double pitch) {
+        double nf = cf * Math.cos(yaw) - cr * Math.sin(yaw);
+        double nr = cf * Math.sin(yaw) + cr * Math.cos(yaw);
+        cf = nf;
+        cr = nr;
+        nf = cf * Math.cos(pitch) - cu * Math.sin(pitch);
+        double nu = cf * Math.sin(pitch) + cu * Math.cos(pitch);
+        cf = nf;
+        cu = nu;
+        normalizeCursor();
+        limitCursor();
+    }
+
+    /** Brings the cursor back towards the reticle along the shortest way, keeping only this fraction of its angle. */
+    private static void shrinkCursor(double keep) {
+        double angle = Math.acos(Mth.clamp(cf, -1.0, 1.0));
+        double lateral = Math.sqrt(cr * cr + cu * cu);
+        if (angle < 1.0E-6 || lateral < 1.0E-9) {
+            cf = 1.0;
+            cr = 0.0;
+            cu = 0.0;
+            return;
+        }
+        double newAngle = angle * keep;
+        double scale = Math.sin(newAngle) / lateral;
+        cf = Math.cos(newAngle);
+        cr *= scale;
+        cu *= scale;
+    }
+
+    private static void normalizeCursor() {
+        double length = Math.sqrt(cf * cf + cr * cr + cu * cu);
+        if (!(length > 1.0E-9)) {
+            cf = 1.0;
+            cr = 0.0;
+            cu = 0.0;
+            return;
+        }
+        cf /= length;
+        cr /= length;
+        cu /= length;
+    }
+
+    private static void limitCursor() {
+        double limit = Math.toRadians(CursorAimClientConfig.MAX_CURSOR_ANGLE_DEGREES.get());
+        double angle = Math.acos(Mth.clamp(cf, -1.0, 1.0));
+        if (angle <= limit) {
+            return;
+        }
+        double lateral = Math.sqrt(cr * cr + cu * cu);
+        if (lateral < 1.0E-9) {
+            return;
+        }
+        double scale = Math.sin(limit) / lateral;
+        cf = Math.cos(limit);
+        cr *= scale;
+        cu *= scale;
+    }
+
+    // ---- Mouse wheel and camera distance ----
+
+    @SubscribeEvent
+    public static void onScroll(InputEvent.MouseScrollingEvent event) {
+        Minecraft minecraft = Minecraft.getInstance();
+        if (!active || minecraft.screen != null) {
+            return;
+        }
+        zoom = Mth.clamp(zoom - event.getScrollDelta() * CursorAimClientConfig.ZOOM_STEP.get(), -3.0, CursorAimClientConfig.ZOOM_MAX.get());
+        event.setCanceled(true);
+    }
+
+    @SubscribeEvent
+    public static void onCameraAngles(ViewportEvent.ComputeCameraAngles event) {
+        if (!active || Math.abs(zoom) < 1.0E-3) {
+            return;
+        }
+        try {
+            if (cameraMove == null) {
+                // Camera.move(double, double, double), moves along the camera's own axes
+                cameraMove = ObfuscationReflectionHelper.findMethod(Camera.class, "m_90568_", double.class, double.class, double.class);
+            }
+            cameraMove.invoke(event.getCamera(), -zoom, 0.0, 0.0);
+        } catch (ReflectiveOperationException | RuntimeException exception) {
+            ImprovedAerodynamics.LOGGER.warn("Cursor aim camera zoom is not available", exception);
+            zoom = 0.0;
+        }
+    }
+
+    // ---- Drawing the cursor ----
+
+    @SubscribeEvent
+    public static void onRenderLevel(RenderLevelStageEvent event) {
+        if (!active || event.getStage() != RenderLevelStageEvent.Stage.AFTER_PARTICLES) {
+            return;
+        }
+        Minecraft minecraft = Minecraft.getInstance();
+        ClientLevel level = minecraft.level;
+        LocalPlayer player = minecraft.player;
+        if (level == null || player == null || !seated(player)) {
+            return;
+        }
+        Entity seat = AimSeat.seatOf(player);
+        AimBasis basis = AimBasis.of(level, seat.blockPosition());
+        Ship ship = VSGameUtilsKt.getLoadedShipManagingPos(level, BlockPos.containing(seat.getX(), seat.getY(), seat.getZ()));
+        if (basis == null || ship == null) {
+            return;
+        }
+        Quaterniondc rotation = ship instanceof ClientShip clientShip
+                ? clientShip.getRenderTransform().getShipToWorldRotation() : ship.getTransform().getShipToWorldRotation();
+        double[] cursorShip = basis.toShip(cf, cr, cu);
+        Vector3d cursorWorld = rotation.transform(new Vector3d(cursorShip[0], cursorShip[1], cursorShip[2]));
+        double[] forward = basis.forward();
+        Vector3d reticleWorld = rotation.transform(new Vector3d(forward[0], forward[1], forward[2]));
+
+        Camera camera = event.getCamera();
+        Matrix4f matrix = event.getPoseStack().last().pose();
+        BufferBuilder builder = Tesselator.getInstance().getBuilder();
+        RenderSystem.disableDepthTest();
+        RenderSystem.enableBlend();
+        RenderSystem.defaultBlendFunc();
+        RenderSystem.disableCull();
+        RenderSystem.setShader(GameRenderer::getPositionColorShader);
+        builder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR);
+
+        float size = (float) (CursorAimClientConfig.MARKER_SIZE.get() * MARKER_DISTANCE);
+        if (CursorAimClientConfig.SHOW_RETICLE.get()) {
+            plus(builder, matrix, camera, reticleWorld, size * 0.35F, RETICLE_COLOR);
+        }
+        ring(builder, matrix, camera, cursorWorld, size, CURSOR_COLOR);
+        BufferUploader.drawWithShader(builder.end());
+
+        RenderSystem.enableCull();
+        RenderSystem.enableDepthTest();
+        RenderSystem.disableBlend();
+    }
+
+    private static Vector3f screenPoint(Camera camera, Vector3d direction) {
+        Vector3f center = new Vector3f((float) direction.x, (float) direction.y, (float) direction.z);
+        if (center.lengthSquared() < 1.0E-9F) {
+            return null;
+        }
+        return center.normalize().mul(MARKER_DISTANCE);
+    }
+
+    private static void ring(BufferBuilder builder, Matrix4f matrix, Camera camera, Vector3d direction, float radius, int color) {
+        Vector3f center = screenPoint(camera, direction);
+        if (center == null) {
+            return;
+        }
+        Vector3f left = new Vector3f(camera.getLeftVector());
+        Vector3f up = new Vector3f(camera.getUpVector());
+        float thickness = radius * 0.12F;
+        GunPipperRenderer.ring(builder, matrix, center, left, up, radius, thickness, color);
+        GunPipperRenderer.quad(builder, matrix, center, left, up, thickness * 1.4F, thickness * 1.4F, color);
+    }
+
+    private static void plus(BufferBuilder builder, Matrix4f matrix, Camera camera, Vector3d direction, float arm, int color) {
+        Vector3f center = screenPoint(camera, direction);
+        if (center == null) {
+            return;
+        }
+        Vector3f left = new Vector3f(camera.getLeftVector());
+        Vector3f up = new Vector3f(camera.getUpVector());
+        float thickness = arm * 0.14F;
+        GunPipperRenderer.quad(builder, matrix, center, left, up, arm, thickness, color);
+        GunPipperRenderer.quad(builder, matrix, center, left, up, thickness, arm, color);
+    }
+
+    // ---- Vector helpers on arrays of three ----
+
+    /** Rotates v about the unit axis by an angle in radians (Rodrigues). */
+    private static double[] rotate(double[] v, double[] axis, double angle) {
+        double c = Math.cos(angle);
+        double s = Math.sin(angle);
+        double dot = v[0] * axis[0] + v[1] * axis[1] + v[2] * axis[2];
+        double cx = axis[1] * v[2] - axis[2] * v[1];
+        double cy = axis[2] * v[0] - axis[0] * v[2];
+        double cz = axis[0] * v[1] - axis[1] * v[0];
+        return new double[]{
+                v[0] * c + cx * s + axis[0] * dot * (1.0 - c),
+                v[1] * c + cy * s + axis[1] * dot * (1.0 - c),
+                v[2] * c + cz * s + axis[2] * dot * (1.0 - c)};
+    }
+
+    /** Turns unit vector a towards unit vector b by a fraction of the angle between them. */
+    private static double[] turnTowards(double[] a, double[] b, double fraction) {
+        double dot = Mth.clamp(a[0] * b[0] + a[1] * b[1] + a[2] * b[2], -1.0, 1.0);
+        double cx = a[1] * b[2] - a[2] * b[1];
+        double cy = a[2] * b[0] - a[0] * b[2];
+        double cz = a[0] * b[1] - a[1] * b[0];
+        double sin = Math.sqrt(cx * cx + cy * cy + cz * cz);
+        if (sin < 1.0E-9) {
+            return dot > 0.0 ? b.clone() : a.clone();
+        }
+        double[] axis = {cx / sin, cy / sin, cz / sin};
+        return rotate(a, axis, Math.acos(dot) * fraction);
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/client/aim/CursorAimClientConfig.java

@@ -0,0 +1,45 @@
+package dev.lumareth.improvedAerodynamics.client.aim;
+
+import net.minecraftforge.common.ForgeConfigSpec;
+
+/** Client side settings of cursor aim. Lives in improved_aerodynamics-cursor-aim-client.toml. */
+public final class CursorAimClientConfig {
+    public static final ForgeConfigSpec SPEC;
+
+    public static final ForgeConfigSpec.DoubleValue LOOK_AHEAD;
+    public static final ForgeConfigSpec.DoubleValue MOUSE_SENSITIVITY;
+    public static final ForgeConfigSpec.DoubleValue SPRING_BACK_SECONDS;
+    public static final ForgeConfigSpec.DoubleValue MAX_CURSOR_ANGLE_DEGREES;
+    public static final ForgeConfigSpec.DoubleValue ZOOM_STEP;
+    public static final ForgeConfigSpec.DoubleValue ZOOM_MAX;
+    public static final ForgeConfigSpec.DoubleValue MARKER_SIZE;
+    public static final ForgeConfigSpec.BooleanValue SHOW_RETICLE;
+
+    static {
+        ForgeConfigSpec.Builder builder = new ForgeConfigSpec.Builder();
+        builder.comment("Cursor aim, client side").push("cursor_aim");
+        LOOK_AHEAD = builder.comment("How strongly the camera looks into the direction of the turn. 0 never moves it, 1 (100%) turns it quickly",
+                        "to look where the cursor points. In between it follows more slowly")
+                .defineInRange("lookAhead", 0.0, 0.0, 1.0);
+        MOUSE_SENSITIVITY = builder.comment("Multiplier for how far the mouse moves the cursor (or the camera while the free look key is held)")
+                .defineInRange("mouseSensitivity", 1.0, 0.05, 10.0);
+        SPRING_BACK_SECONDS = builder.comment("The cursor returns to the gun reticle with this time constant in seconds when you stop moving the mouse.",
+                        "0 makes it stay where you left it")
+                .defineInRange("springBackSeconds", 1.0, 0.0, 10.0);
+        MAX_CURSOR_ANGLE_DEGREES = builder.comment("Furthest the cursor can go from the gun reticle, 135 is a 270 degree cone")
+                .defineInRange("maxCursorAngleDegrees", 135.0, 10.0, 180.0);
+        ZOOM_STEP = builder.comment("Blocks the camera moves per mouse wheel notch")
+                .defineInRange("zoomStep", 2.0, 0.1, 20.0);
+        ZOOM_MAX = builder.comment("Furthest the camera can be pulled back from its normal distance, in blocks")
+                .defineInRange("zoomMax", 80.0, 0.0, 500.0);
+        MARKER_SIZE = builder.comment("Radius of the cursor ring on screen")
+                .defineInRange("markerSize", 0.04, 0.01, 0.3);
+        SHOW_RETICLE = builder.comment("Draw a small cross where the gun reticle points, the zero of the cursor, so you can see it when the camera looks away")
+                .define("showReticle", true);
+        builder.pop();
+        SPEC = builder.build();
+    }
+
+    private CursorAimClientConfig() {
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/client/pipper/Ballistics.java

@@ -0,0 +1,147 @@
+package dev.lumareth.improvedAerodynamics.client.pipper;
+
+/**
+ * Flight of a Warium shell, which is a vanilla arrow: every tick it moves by its velocity, the velocity is then scaled
+ * by the drag and gravity is subtracted. That is linear in the launch velocity, so the position after n ticks is
+ * <pre>M + D(n) * v0 - (0, G(n), 0)</pre>
+ * with D(n) the sum of the drag factors and G(n) the drop gravity causes on its own. Both are tabulated once, which
+ * makes both the impact point and the lead solution cheap enough to run every frame.
+ * <p>
+ * Plain doubles and no Minecraft classes, so it can be tested on its own. Units are blocks and ticks.
+ */
+public final class Ballistics {
+    public static final int MAX_TICKS = 400;
+
+    private final double[] d = new double[MAX_TICKS + 1];
+    private final double[] g = new double[MAX_TICKS + 1];
+
+    public Ballistics(double drag, double gravity) {
+        double y = 0.0;
+        double vy = 0.0;
+        double sum = 0.0;
+        double factor = 1.0;
+        for (int n = 1; n <= MAX_TICKS; n++) {
+            y += vy;
+            vy = vy * drag - gravity;
+            sum += factor;
+            factor *= drag;
+            d[n] = sum;
+            g[n] = -y;
+        }
+    }
+
+    /** Sum of the drag factors after n ticks, n may be fractional. */
+    public double d(double n) {
+        return interpolate(d, n);
+    }
+
+    /** Drop in blocks after n ticks, n may be fractional. */
+    public double g(double n) {
+        return interpolate(g, n);
+    }
+
+    private static double interpolate(double[] table, double n) {
+        if (n <= 0.0) {
+            return 0.0;
+        }
+        if (n >= MAX_TICKS) {
+            return table[MAX_TICKS];
+        }
+        int i = (int) n;
+        double f = n - i;
+        return table[i] + (table[i + 1] - table[i]) * f;
+    }
+
+    /** Height of the terrain a shell would hit at a column. */
+    public interface Ground {
+        double heightAt(double x, double z);
+    }
+
+    /**
+     * Where a shell fired from the muzzle with the given world velocity (blocks per tick, already including the
+     * speed of the shooter if shells inherit it) comes down. Returns the impact point as {x, y, z} or null if it
+     * stays in the air for the whole table.
+     */
+    public double[] impact(double mx, double my, double mz, double vx, double vy, double vz, Ground ground) {
+        double px = mx;
+        double py = my;
+        double pz = mz;
+        for (int n = 1; n <= MAX_TICKS; n++) {
+            double nx = mx + d[n] * vx;
+            double ny = my + d[n] * vy - g[n];
+            double nz = mz + d[n] * vz;
+            double floor = ground.heightAt(nx, nz);
+            if (ny <= floor) {
+                // Linear crossing inside this step
+                double before = py - ground.heightAt(px, pz);
+                double after = ny - floor;
+                double f = before - after > 1.0E-9 ? Math.min(1.0, Math.max(0.0, before / (before - after))) : 1.0;
+                return new double[] {px + (nx - px) * f, py + (ny - py) * f, pz + (nz - pz) * f};
+            }
+            px = nx;
+            py = ny;
+            pz = nz;
+        }
+        return null;
+    }
+
+    /** Result of {@link #lead}: aim direction, time of flight in ticks and the range to the target's current position. */
+    public record Lead(double dirX, double dirY, double dirZ, double ticks, double range) {
+    }
+
+    /**
+     * Aim direction that makes a shell meet a moving target.
+     *
+     * @param speed  muzzle speed in blocks per tick
+     * @param t*     target position now
+     * @param tv*    target velocity in blocks per tick
+     * @param sv*    velocity the shell inherits from the shooter in blocks per tick, zero if it does not
+     * @return the solution or null if the shell cannot reach the target within the table
+     */
+    public Lead lead(double mx, double my, double mz, double speed, double tx, double ty, double tz,
+                     double tvx, double tvy, double tvz, double svx, double svy, double svz) {
+        double range = Math.sqrt(sq(tx - mx) + sq(ty - my) + sq(tz - mz));
+        double previousN = 0.0;
+        for (int n = 1; n <= MAX_TICKS; n++) {
+            double f = miss(n, mx, my, mz, speed, tx, ty, tz, tvx, tvy, tvz, svx, svy, svz);
+            if (f <= 0.0) {
+                double lo = previousN;
+                double hi = n;
+                for (int i = 0; i < 30; i++) {
+                    double mid = 0.5 * (lo + hi);
+                    if (miss(mid, mx, my, mz, speed, tx, ty, tz, tvx, tvy, tvz, svx, svy, svz) > 0.0) {
+                        lo = mid;
+                    } else {
+                        hi = mid;
+                    }
+                }
+                double t = 0.5 * (lo + hi);
+                double dn = d(t);
+                double rx = tx + tvx * t - mx - dn * svx;
+                double ry = ty + tvy * t - my - dn * svy + g(t);
+                double rz = tz + tvz * t - mz - dn * svz;
+                double length = Math.sqrt(rx * rx + ry * ry + rz * rz);
+                if (length < 1.0E-6) {
+                    return null;
+                }
+                return new Lead(rx / length, ry / length, rz / length, t, range);
+            }
+            previousN = n;
+        }
+        return null;
+    }
+
+    /** Distance the shell can still cover short of where the target will be, positive means it has not got there yet. */
+    private double miss(double n, double mx, double my, double mz, double speed, double tx, double ty, double tz,
+                        double tvx, double tvy, double tvz, double svx, double svy, double svz) {
+        double dn = d(n);
+        double rx = tx + tvx * n - mx - dn * svx;
+        double ry = ty + tvy * n - my - dn * svy + g(n);
+        double rz = tz + tvz * n - mz - dn * svz;
+        return Math.sqrt(rx * rx + ry * ry + rz * rz) - speed * dn;
+    }
+
+    private static double sq(double v) {
+        return v * v;
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/client/pipper/GunFinder.java

@@ -0,0 +1,155 @@
+package dev.lumareth.improvedAerodynamics.client.pipper;
+
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.DirectionProperty;
+import net.minecraft.world.level.block.state.properties.Property;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.chunk.LevelChunkSection;
+import net.minecraftforge.fml.ModList;
+import net.minecraftforge.registries.ForgeRegistries;
+import org.joml.primitives.AABBic;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Finds the light autocannon of a ship and works out what it will shoot, the same way Warium's LACFireScript does:
+ * barrel count, muzzle, aim direction and muzzle speed.
+ */
+final class GunFinder {
+    private static final ResourceLocation LIGHT_AUTOCANNON = new ResourceLocation("crusty_chunks", "light_autocannon");
+    private static final TagKey<Block> BARREL = TagKey.create(Registries.BLOCK, new ResourceLocation("crusty_chunks", "acbarrel"));
+    private static final TagKey<Block> PASSTHROUGH = TagKey.create(Registries.BLOCK, new ResourceLocation("crusty_chunks", "barrelpassthrough"));
+    private static final int RESCAN_TICKS = 100;
+    private static final int MAX_GUNS = 16;
+
+    /** Muzzle and direction in ship space and the speed of the shell in blocks per tick. */
+    record Shot(double mx, double my, double mz, double dx, double dy, double dz, double speed) {
+    }
+
+    private long shipId = Long.MIN_VALUE;
+    private long lastScan = Long.MIN_VALUE;
+    private final List<BlockPos> guns = new ArrayList<>();
+
+    /** The gun closest to the seat, or null if the ship has none loaded. */
+    Shot find(ClientLevel level, long shipId, AABBic aabb, BlockPos seat) {
+        if (shipId != this.shipId || level.getGameTime() - lastScan >= RESCAN_TICKS || level.getGameTime() < lastScan) {
+            this.shipId = shipId;
+            lastScan = level.getGameTime();
+            scan(level, aabb);
+        }
+        BlockPos best = null;
+        double bestDistance = Double.MAX_VALUE;
+        for (BlockPos pos : guns) {
+            double distance = pos.distSqr(seat);
+            if (distance < bestDistance) {
+                bestDistance = distance;
+                best = pos;
+            }
+        }
+        return best == null ? null : shotOf(level, best);
+    }
+
+    private void scan(ClientLevel level, AABBic aabb) {
+        guns.clear();
+        Block gun = ForgeRegistries.BLOCKS.getValue(LIGHT_AUTOCANNON);
+        if (gun == null || aabb == null) {
+            return;
+        }
+        BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos();
+        for (int cx = aabb.minX() >> 4; cx <= aabb.maxX() >> 4; cx++) {
+            for (int cz = aabb.minZ() >> 4; cz <= aabb.maxZ() >> 4; cz++) {
+                ChunkAccess chunk = level.getChunk(cx, cz, ChunkStatus.FULL, false);
+                if (chunk == null) {
+                    continue;
+                }
+                LevelChunkSection[] sections = chunk.getSections();
+                for (int i = 0; i < sections.length; i++) {
+                    LevelChunkSection section = sections[i];
+                    if (section.hasOnlyAir() || !section.maybeHas(state -> state.is(gun))) {
+                        continue;
+                    }
+                    int baseY = level.getSectionYFromSectionIndex(i) << 4;
+                    for (int x = 0; x < 16; x++) {
+                        for (int y = 0; y < 16; y++) {
+                            for (int z = 0; z < 16; z++) {
+                                if (section.getBlockState(x, y, z).is(gun) && guns.size() < MAX_GUNS) {
+                                    guns.add(pos.set((cx << 4) + x, baseY + y, (cz << 4) + z).immutable());
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private static Shot shotOf(ClientLevel level, BlockPos gun) {
+        BlockState state = level.getBlockState(gun);
+        Property<?> property = state.getBlock().getStateDefinition().getProperty("facing");
+        if (!(property instanceof DirectionProperty facingProperty)) {
+            return null;
+        }
+        Direction facing = state.getValue(facingProperty);
+        int fx = facing.getStepX();
+        int fy = facing.getStepY();
+        int fz = facing.getStepZ();
+
+        // Barrels, counted like Warium does: up to five more behind the first one
+        double barrels = 1.0;
+        for (int i = 0; i < 5 && level.getBlockState(gun.offset(fx * (int) (1 + barrels), fy * (int) (1 + barrels), fz * (int) (1 + barrels))).is(BARREL); i++) {
+            barrels++;
+        }
+        // Muzzle: past the barrels, skipping through blocks the shell passes
+        double position = barrels;
+        for (int i = 0; i < 10; i++) {
+            BlockState at = level.getBlockState(gun.offset(fx * (int) (1 + position), fy * (int) (1 + position), fz * (int) (1 + position)));
+            if ((!at.isAir() && !at.canOcclude()) || at.is(PASSTHROUGH)) {
+                position++;
+            } else {
+                break;
+            }
+        }
+        double mx = gun.getX() + fx * (1.5 + position) + 0.5;
+        double my = gun.getY() + fy * (1.5 + position) + 0.5;
+        double mz = gun.getZ() + fz * (1.5 + position) + 0.5;
+
+        // Aim, from the tags of the gun itself
+        double aimX = 0.0;
+        double aimY = 0.0;
+        double aimZ = 0.0;
+        BlockEntity entity = level.getBlockEntity(gun);
+        double gx = entity == null ? 0.0 : entity.getPersistentData().getDouble("X");
+        double gz = entity == null ? 0.0 : entity.getPersistentData().getDouble("Z");
+        double gpitch = entity == null ? 0.0 : entity.getPersistentData().getDouble("Pitch");
+        if (1.0 > Math.abs(fx - gx) || 1.0 > Math.abs(fz - gz)) {
+            aimY = gpitch;
+            aimX = gx + fx;
+            aimZ = gz + fz;
+        }
+        if (aimX * aimZ == 0.0) {
+            aimX = fx;
+            aimZ = fz;
+        }
+        double length = Math.sqrt(aimX * aimX + aimY * aimY + aimZ * aimZ);
+        if (length < 1.0E-6) {
+            return null;
+        }
+
+        double speed = PipperConfig.MUZZLE_SPEED_OVERRIDE.get();
+        if (speed <= 0.0) {
+            double multiplier = ModList.get().isLoaded("ritchiesprojectilelib") ? 2.0 : 1.0;
+            speed = (5.0 + barrels / 1.5) * multiplier;
+        }
+        return new Shot(mx, my, mz, aimX / length, aimY / length, aimZ / length, speed);
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/client/pipper/GunPipperRenderer.java

@@ -0,0 +1,251 @@
+package dev.lumareth.improvedAerodynamics.client.pipper;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.BufferBuilder;
+import com.mojang.blaze3d.vertex.BufferUploader;
+import com.mojang.blaze3d.vertex.DefaultVertexFormat;
+import com.mojang.blaze3d.vertex.Tesselator;
+import com.mojang.blaze3d.vertex.VertexFormat;
+import dev.lumareth.improvedAerodynamics.ImprovedAerodynamics;
+import net.minecraft.client.Camera;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.core.BlockPos;
+import net.minecraft.util.Mth;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.minecraft.world.phys.Vec3;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.client.event.RenderLevelStageEvent;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.ModList;
+import net.minecraftforge.fml.common.Mod;
+import org.joml.Matrix4f;
+import org.joml.Vector3d;
+import org.joml.Vector3f;
+import org.valkyrienskies.core.api.ships.ClientShip;
+import org.valkyrienskies.core.api.ships.Ship;
+import org.valkyrienskies.mod.common.VSGameUtilsKt;
+
+/**
+ * Draws two markers for the first light autocannon of the aircraft you sit in:
+ * an orange ring where its shells come down on the ground, and, for the radar target selected on the seat, a green
+ * ring you put on the target to hit it (the lead pipper): green from the radar, cyan while following the ship itself,
+ * yellow while only extrapolating a lost contact. Both come from the same ballistics Warium's shells follow.
+ */
+@Mod.EventBusSubscriber(modid = ImprovedAerodynamics.MOD_ID, value = Dist.CLIENT)
+public final class GunPipperRenderer {
+    private static final int IMPACT_COLOR = 0xFFFF9020;
+    private static final int LEAD_COLOR = 0xFF40FF60;
+    private static final int VISUAL_COLOR = 0xFF40E8FF;
+    private static final int COAST_COLOR = 0xFFFFE040;
+    private static final float DISTANCE = 2.0F;
+
+    private static final GunFinder FINDER = new GunFinder();
+    private static final TargetTrack TRACK = new TargetTrack();
+    private static Ballistics ballistics;
+    private static double ballisticsDrag = Double.NaN;
+    private static double ballisticsGravity = Double.NaN;
+
+    private GunPipperRenderer() {
+    }
+
+    @SubscribeEvent
+    public static void onRenderLevel(RenderLevelStageEvent event) {
+        if (event.getStage() != RenderLevelStageEvent.Stage.AFTER_PARTICLES || !PipperConfig.SPEC.isLoaded()
+                || !PipperConfig.ENABLED.get() || !ModList.get().isLoaded("valkyrien_warium")) {
+            return;
+        }
+        Minecraft minecraft = Minecraft.getInstance();
+        ClientLevel level = minecraft.level;
+        if (level == null || minecraft.player == null) {
+            return;
+        }
+        Entity seat = WariumSeat.seatOf(minecraft.player);
+        if (seat == null) {
+            TRACK.reset();
+            return;
+        }
+        BlockPos seatPos = BlockPos.containing(seat.getX(), seat.getY(), seat.getZ());
+        Ship ship = VSGameUtilsKt.getLoadedShipManagingPos(level, seatPos);
+        if (ship == null) {
+            return;
+        }
+
+        GunFinder.Shot shot = FINDER.find(level, ship.getId(), ship.getShipAABB(), seatPos);
+        if (shot == null) {
+            return;
+        }
+        org.joml.Matrix4dc shipToWorld = ship instanceof ClientShip clientShip
+                ? clientShip.getRenderTransform().getShipToWorld() : ship.getShipToWorld();
+        Vector3d muzzle = shipToWorld.transformPosition(new Vector3d(shot.mx(), shot.my(), shot.mz()));
+        Vector3d direction = shipToWorld.transformDirection(new Vector3d(shot.dx(), shot.dy(), shot.dz())).normalize();
+
+        double inherit = PipperConfig.INHERIT_SHIP_VELOCITY.get() ? 1.0 / 20.0 : 0.0;
+        org.joml.Vector3dc velocity = ship.getVelocity();
+        double svx = velocity.x() * inherit;
+        double svy = velocity.y() * inherit;
+        double svz = velocity.z() * inherit;
+
+        Ballistics table = table();
+        Camera camera = event.getCamera();
+        Matrix4f matrix = event.getPoseStack().last().pose();
+
+        BufferBuilder builder = Tesselator.getInstance().getBuilder();
+        RenderSystem.disableDepthTest();
+        RenderSystem.enableBlend();
+        RenderSystem.defaultBlendFunc();
+        RenderSystem.disableCull();
+        RenderSystem.setShader(GameRenderer::getPositionColorShader);
+        builder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR);
+        boolean drawn = false;
+
+        if (PipperConfig.SHOW_IMPACT.get()) {
+            double[] impact = table.impact(muzzle.x, muzzle.y, muzzle.z,
+                    direction.x * shot.speed() + svx, direction.y * shot.speed() + svy, direction.z * shot.speed() + svz,
+                    (x, z) -> level.getHeight(Heightmap.Types.MOTION_BLOCKING, Mth.floor(x), Mth.floor(z)));
+            if (impact != null) {
+                drawn |= marker(builder, matrix, camera, impact[0], impact[1], impact[2], IMPACT_COLOR, false);
+            }
+        }
+
+        if (PipperConfig.SHOW_LEAD.get()) {
+            drawn |= lead(builder, matrix, camera, level, seat, seatPos, ship.getId(), table, muzzle, shot.speed(), svx, svy, svz);
+        } else {
+            TRACK.reset();
+        }
+
+        if (drawn) {
+            BufferUploader.drawWithShader(builder.end());
+        } else {
+            builder.end().release();
+        }
+        RenderSystem.enableCull();
+        RenderSystem.enableDepthTest();
+        RenderSystem.disableBlend();
+    }
+
+    private static boolean lead(BufferBuilder builder, Matrix4f matrix, Camera camera, ClientLevel level, Entity seat, BlockPos seatPos,
+                                long ownShipId, Ballistics table, Vector3d muzzle, double speed, double svx, double svy, double svz) {
+        int selected = WariumSeat.selectedTarget(seat);
+        double[] radar = selected > 0 ? radarPosition(level, seatPos, selected) : null;
+        TargetTrack.Fix fix = TRACK.resolve(level, ownShipId, selected, radar, level.getGameTime(),
+                PipperConfig.VISUAL_TRACK.get(), PipperConfig.COAST_SECONDS.get());
+        if (fix == null) {
+            return false;
+        }
+        Ballistics.Lead lead = table.lead(muzzle.x, muzzle.y, muzzle.z, speed, fix.x(), fix.y(), fix.z(),
+                fix.vx(), fix.vy(), fix.vz(), svx, svy, svz);
+        if (lead == null) {
+            return false;
+        }
+        int color = switch (fix.source()) {
+            case RADAR -> LEAD_COLOR;
+            case VISUAL -> VISUAL_COLOR;
+            case COAST -> COAST_COLOR;
+        };
+        return marker(builder, matrix, camera,
+                muzzle.x + lead.dirX() * lead.range(), muzzle.y + lead.dirY() * lead.range(), muzzle.z + lead.dirZ() * lead.range(),
+                color, true);
+    }
+
+    /** Position the node reports for a target index, or null if it reports none. */
+    private static double[] radarPosition(ClientLevel level, BlockPos seatPos, int selected) {
+        BlockEntity seatEntity = level.getBlockEntity(seatPos);
+        if (seatEntity == null) {
+            return null;
+        }
+        var seatData = seatEntity.getPersistentData();
+        BlockEntity node = level.getBlockEntity(BlockPos.containing(seatData.getDouble("ControlX"), seatData.getDouble("ControlY"), seatData.getDouble("ControlZ")));
+        if (node == null) {
+            return null;
+        }
+        var data = node.getPersistentData();
+        // Warium builds these keys from a double, so they read TargetX1.0, TargetY1.0 and so on
+        double tx = data.getDouble("TargetX" + (double) selected);
+        double ty = data.getDouble("TargetY" + (double) selected);
+        double tz = data.getDouble("TargetZ" + (double) selected);
+        if (tx == 0.0 && ty == 0.0 && tz == 0.0) {
+            return null;
+        }
+        return new double[] {tx, ty, tz};
+    }
+
+    private static Ballistics table() {
+        double drag = PipperConfig.DRAG.get();
+        double gravity = PipperConfig.GRAVITY.get();
+        if (ballistics == null || drag != ballisticsDrag || gravity != ballisticsGravity) {
+            ballistics = new Ballistics(drag, gravity);
+            ballisticsDrag = drag;
+            ballisticsGravity = gravity;
+        }
+        return ballistics;
+    }
+
+    /** A ring on the screen in the direction of a world point, with ticks on it for the lead pipper. */
+    private static boolean marker(BufferBuilder builder, Matrix4f matrix, Camera camera, double x, double y, double z, int color, boolean ticks) {
+        Vec3 cameraPosition = camera.getPosition();
+        Vector3f toPoint = new Vector3f((float) (x - cameraPosition.x), (float) (y - cameraPosition.y), (float) (z - cameraPosition.z));
+        if (toPoint.lengthSquared() < 1.0E-6F) {
+            return false;
+        }
+        toPoint.normalize();
+        if (toPoint.dot(camera.getLookVector()) <= 0.05F) {
+            return false;
+        }
+        Vector3f center = new Vector3f(toPoint).mul(DISTANCE);
+        Vector3f left = new Vector3f(camera.getLeftVector());
+        Vector3f up = new Vector3f(camera.getUpVector());
+        float radius = (float) (PipperConfig.MARKER_SIZE.get() * DISTANCE);
+        float thickness = radius * 0.12F;
+
+        ring(builder, matrix, center, left, up, radius, thickness, color);
+        quad(builder, matrix, center, left, up, thickness * 1.6F, thickness * 1.6F, color);
+        if (ticks) {
+            for (int i = 0; i < 4; i++) {
+                double angle = i * Math.PI / 2.0;
+                float cx = (float) Math.cos(angle);
+                float cy = (float) Math.sin(angle);
+                Vector3f tickCenter = new Vector3f(center)
+                        .fma(cx * radius * 1.45F, left).fma(cy * radius * 1.45F, up);
+                float halfX = Math.abs(cx) > 0.5F ? radius * 0.35F : thickness;
+                float halfY = Math.abs(cy) > 0.5F ? radius * 0.35F : thickness;
+                quad(builder, matrix, tickCenter, left, up, halfX, halfY, color);
+            }
+        }
+        return true;
+    }
+
+    public static void ring(BufferBuilder builder, Matrix4f matrix, Vector3f center, Vector3f left, Vector3f up, float radius, float thickness, int color) {
+        final int segments = 32;
+        float inner = radius - thickness;
+        float outer = radius + thickness;
+        for (int i = 0; i < segments; i++) {
+            double a0 = i * 2.0 * Math.PI / segments;
+            double a1 = (i + 1) * 2.0 * Math.PI / segments;
+            vertex(builder, matrix, center, left, up, (float) Math.cos(a0) * inner, (float) Math.sin(a0) * inner, color);
+            vertex(builder, matrix, center, left, up, (float) Math.cos(a0) * outer, (float) Math.sin(a0) * outer, color);
+            vertex(builder, matrix, center, left, up, (float) Math.cos(a1) * outer, (float) Math.sin(a1) * outer, color);
+            vertex(builder, matrix, center, left, up, (float) Math.cos(a1) * inner, (float) Math.sin(a1) * inner, color);
+        }
+    }
+
+    public static void quad(BufferBuilder builder, Matrix4f matrix, Vector3f center, Vector3f left, Vector3f up, float halfX, float halfY, int color) {
+        vertex(builder, matrix, center, left, up, -halfX, -halfY, color);
+        vertex(builder, matrix, center, left, up, halfX, -halfY, color);
+        vertex(builder, matrix, center, left, up, halfX, halfY, color);
+        vertex(builder, matrix, center, left, up, -halfX, halfY, color);
+    }
+
+    private static void vertex(BufferBuilder builder, Matrix4f matrix, Vector3f center, Vector3f left, Vector3f up, float a, float b, int color) {
+        // The left vector points to the left of the screen, so a positive offset along it is drawn to the left
+        float vx = center.x - left.x * a + up.x * b;
+        float vy = center.y - left.y * a + up.y * b;
+        float vz = center.z - left.z * a + up.z * b;
+        builder.vertex(matrix, vx, vy, vz)
+                .color(color >> 16 & 255, color >> 8 & 255, color & 255, color >>> 24)
+                .endVertex();
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/client/pipper/PipperConfig.java

@@ -0,0 +1,53 @@
+package dev.lumareth.improvedAerodynamics.client.pipper;
+
+import net.minecraftforge.common.ForgeConfigSpec;
+
+/** Client side settings of the gun pipper. Lives in improved_aerodynamics-client.toml. */
+public final class PipperConfig {
+    public static final ForgeConfigSpec SPEC;
+
+    public static final ForgeConfigSpec.BooleanValue ENABLED;
+    public static final ForgeConfigSpec.BooleanValue SHOW_IMPACT;
+    public static final ForgeConfigSpec.BooleanValue SHOW_LEAD;
+    public static final ForgeConfigSpec.BooleanValue INHERIT_SHIP_VELOCITY;
+    public static final ForgeConfigSpec.BooleanValue VISUAL_TRACK;
+    public static final ForgeConfigSpec.DoubleValue COAST_SECONDS;
+    public static final ForgeConfigSpec.DoubleValue MUZZLE_SPEED_OVERRIDE;
+    public static final ForgeConfigSpec.DoubleValue GRAVITY;
+    public static final ForgeConfigSpec.DoubleValue DRAG;
+    public static final ForgeConfigSpec.DoubleValue MARKER_SIZE;
+
+    static {
+        ForgeConfigSpec.Builder builder = new ForgeConfigSpec.Builder();
+        builder.comment("Gun pipper for Warium light autocannons, drawn while seated in a Warium seat").push("pipper");
+        ENABLED = builder.comment("Master switch")
+                .define("enabled", true);
+        SHOW_IMPACT = builder.comment("Show where the shells of the gun come down on the ground (orange ring)")
+                .define("showImpact", true);
+        SHOW_LEAD = builder.comment("Show the lead pipper for the radar target you selected (green ring)")
+                .define("showLead", true);
+        VISUAL_TRACK = builder.comment("Follow the selected target's ship itself once the radar has shown it, so the lead pipper keeps working when",
+                        "the radar loses it (notching, speed gate, ground clutter). Only while the ship is loaded, which is within render distance",
+                        "(cyan ring)")
+                .define("visualTrack", true);
+        COAST_SECONDS = builder.comment("Seconds a lost radar contact is extrapolated from its last position and velocity when its ship is not loaded",
+                        "(yellow ring), 0 turns it off")
+                .defineInRange("coastSeconds", 8.0, 0.0, 60.0);
+        INHERIT_SHIP_VELOCITY = builder.comment("Add the speed of your aircraft to the shells. Warium does not do this itself, only turn it",
+                        "on if a test shows your shells keep the speed of the jet (fire level at full speed, then hovering)")
+                .define("inheritShipVelocity", false);
+        MUZZLE_SPEED_OVERRIDE = builder.comment("Muzzle speed in blocks per tick, 0 works it out from the barrel length like Warium does")
+                .defineInRange("muzzleSpeedOverride", 0.0, 0.0, 100.0);
+        GRAVITY = builder.comment("Gravity of the shells in blocks per tick squared")
+                .defineInRange("gravity", 0.05, 0.0, 1.0);
+        DRAG = builder.comment("Speed the shells keep each tick, 0.99 is a vanilla arrow")
+                .defineInRange("drag", 0.99, 0.5, 1.0);
+        MARKER_SIZE = builder.comment("Radius of the markers on screen")
+                .defineInRange("markerSize", 0.03, 0.005, 0.2);
+        builder.pop();
+        SPEC = builder.build();
+    }
+
+    private PipperConfig() {
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/client/pipper/TargetTrack.java

@@ -0,0 +1,131 @@
+package dev.lumareth.improvedAerodynamics.client.pipper;
+
+import net.minecraft.client.multiplayer.ClientLevel;
+import org.joml.Vector3d;
+import org.joml.primitives.AABBdc;
+import org.valkyrienskies.core.api.ships.ClientShip;
+import org.valkyrienskies.mod.common.VSGameUtilsKt;
+
+/**
+ * The target the lead pipper aims at. The radar is only the way in: its contact is matched to the closest loaded ship
+ * and from then on that ship is followed directly, with its true position and velocity, so the pipper survives the
+ * radar losing the contact (notching, the speed gate, ground clutter). Without a loaded ship, which happens beyond
+ * render distance, the last radar position is extrapolated for a limited time.
+ * <p>
+ * The selected index is no help for this: the radar rebuilds its list, so after a loss the index can point at another
+ * contact or at an empty slot.
+ */
+final class TargetTrack {
+    /** A radar position this close to a ship is taken to be that ship. */
+    private static final double SNAP_BLOCKS = 80.0;
+    /** A fresh radar position this far from the followed ship means the player moved on to another target. */
+    private static final double REBIND_BLOCKS = 250.0;
+    private static final long NONE = Long.MIN_VALUE;
+
+    enum Source {
+        RADAR, VISUAL, COAST
+    }
+
+    /** Position in blocks, velocity in blocks per tick. */
+    record Fix(double x, double y, double z, double vx, double vy, double vz, Source source) {
+    }
+
+    private final TargetTracker radar = new TargetTracker();
+    private int index = -1;
+    private long boundId = NONE;
+
+    void reset() {
+        radar.reset();
+        index = -1;
+        boundId = NONE;
+    }
+
+    /**
+     * @param radarPosition the position the node reports for the selected index, or null if it reports none
+     */
+    Fix resolve(ClientLevel level, long ownShipId, int selected, double[] radarPosition, long tick,
+                boolean visualTrack, double coastSeconds) {
+        if (selected <= 0) {
+            reset();
+            return null;
+        }
+        if (selected != index) {
+            reset();
+            index = selected;
+        }
+        if (radarPosition != null) {
+            radar.update(selected, radarPosition[0], radarPosition[1], radarPosition[2], tick);
+        }
+
+        if (visualTrack) {
+            ClientShip bound = boundId == NONE ? null : shipById(level, boundId);
+            if (radarPosition != null && radar.age(tick) <= 1) {
+                // Fresh contact: pick the ship it belongs to, or let go of the old one if the player switched
+                if (bound == null || distance(center(bound), radarPosition) > REBIND_BLOCKS) {
+                    bound = nearest(level, ownShipId, radarPosition);
+                    boundId = bound == null ? NONE : bound.getId();
+                }
+            }
+            if (bound != null) {
+                Vector3d center = center(bound);
+                var velocity = bound.getVelocity();
+                return new Fix(center.x, center.y, center.z, velocity.x() / 20.0, velocity.y() / 20.0, velocity.z() / 20.0, Source.VISUAL);
+            }
+            boundId = NONE;
+        }
+
+        if (!radar.hasPosition()) {
+            return null;
+        }
+        long age = radar.age(tick);
+        if (age > TargetTracker.STALE_TICKS) {
+            if (coastSeconds <= 0.0 || !radar.hasVelocity() || age > coastSeconds * 20.0) {
+                return null;
+            }
+            double[] p = radar.predicted(tick);
+            return new Fix(p[0], p[1], p[2], radar.vx(), radar.vy(), radar.vz(), Source.COAST);
+        }
+        double[] p = radar.predicted(tick);
+        // A contact is only extrapolated up to the age of its last update
+        return new Fix(p[0], p[1], p[2], radar.vx(), radar.vy(), radar.vz(), Source.RADAR);
+    }
+
+    private static ClientShip shipById(ClientLevel level, long id) {
+        for (ClientShip ship : VSGameUtilsKt.getShipObjectWorld(level).getLoadedShips()) {
+            if (ship.getId() == id) {
+                return ship;
+            }
+        }
+        return null;
+    }
+
+    private static ClientShip nearest(ClientLevel level, long ownShipId, double[] position) {
+        ClientShip best = null;
+        double bestDistance = SNAP_BLOCKS;
+        for (ClientShip ship : VSGameUtilsKt.getShipObjectWorld(level).getLoadedShips()) {
+            if (ship.getId() == ownShipId) {
+                continue;
+            }
+            double distance = distance(center(ship), position);
+            if (distance < bestDistance) {
+                bestDistance = distance;
+                best = ship;
+            }
+        }
+        return best;
+    }
+
+    /** The same point Warium's radar reports: the center of the world bounding box. */
+    private static Vector3d center(ClientShip ship) {
+        AABBdc box = ship.getWorldAABB();
+        return box.center(new Vector3d());
+    }
+
+    private static double distance(Vector3d a, double[] b) {
+        return Math.sqrt(sq(a.x - b[0]) + sq(a.y - b[1]) + sq(a.z - b[2]));
+    }
+
+    private static double sq(double v) {
+        return v * v;
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/client/pipper/TargetTracker.java

@@ -0,0 +1,113 @@
+package dev.lumareth.improvedAerodynamics.client.pipper;
+
+/**
+ * Target velocity from the radar. The node only stores positions, and they change when the radar updates, which is
+ * not every tick. So the velocity is the change between two distinct positions divided by the ticks between them,
+ * smoothed. When the radar stops updating the last velocity is kept so the track can be extrapolated.
+ */
+final class TargetTracker {
+    /** Ticks without a new position after which the contact counts as lost and is only extrapolated. */
+    static final long STALE_TICKS = 40;
+    private static final double SMOOTHING = 0.5;
+    private static final double JUMP_BLOCKS_PER_TICK = 15.0;
+
+    private int index = -1;
+    private double px;
+    private double py;
+    private double pz;
+    private long sampleTick;
+    private double vx;
+    private double vy;
+    private double vz;
+    private boolean hasVelocity;
+
+    void update(int selected, double x, double y, double z, long tick) {
+        if (selected != index || tick < sampleTick) {
+            index = selected;
+            px = x;
+            py = y;
+            pz = z;
+            sampleTick = tick;
+            hasVelocity = false;
+            vx = 0.0;
+            vy = 0.0;
+            vz = 0.0;
+            return;
+        }
+        if (x != px || y != py || z != pz) {
+            long dt = Math.max(1L, tick - sampleTick);
+            double nx = (x - px) / dt;
+            double ny = (y - py) / dt;
+            double nz = (z - pz) / dt;
+            if (Math.sqrt(nx * nx + ny * ny + nz * nz) > JUMP_BLOCKS_PER_TICK) {
+                // Teleport or a different contact reusing the slot
+                hasVelocity = false;
+            } else if (hasVelocity) {
+                vx += (nx - vx) * SMOOTHING;
+                vy += (ny - vy) * SMOOTHING;
+                vz += (nz - vz) * SMOOTHING;
+            } else {
+                vx = nx;
+                vy = ny;
+                vz = nz;
+                hasVelocity = true;
+            }
+            px = x;
+            py = y;
+            pz = z;
+            sampleTick = tick;
+        }
+    }
+
+    void reset() {
+        index = -1;
+        hasVelocity = false;
+        vx = 0.0;
+        vy = 0.0;
+        vz = 0.0;
+    }
+
+    boolean hasPosition() {
+        return index >= 0;
+    }
+
+    /** Ticks since the radar last gave a new position. */
+    long age(long tick) {
+        return tick - sampleTick;
+    }
+
+    /** The last radar position moved on by the velocity over the time since. */
+    double[] predicted(long tick) {
+        long dt = Math.max(0L, tick - sampleTick);
+        return new double[] {px + vx * dt, py + vy * dt, pz + vz * dt};
+    }
+
+    double lastX() {
+        return px;
+    }
+
+    double lastY() {
+        return py;
+    }
+
+    double lastZ() {
+        return pz;
+    }
+
+    /** Velocity in blocks per tick, zero when unknown. */
+    double vx() {
+        return vx;
+    }
+
+    double vy() {
+        return vy;
+    }
+
+    double vz() {
+        return vz;
+    }
+
+    boolean hasVelocity() {
+        return hasVelocity;
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/client/pipper/WariumSeat.java

@@ -0,0 +1,20 @@
+package dev.lumareth.improvedAerodynamics.client.pipper;
+
+import net.mcreator.valkyrienwarium.entity.SeatEntityEntity;
+import net.minecraft.world.entity.Entity;
+
+/** Everything that touches Warium VS classes, so nothing else loads them when Warium is missing. */
+final class WariumSeat {
+    private WariumSeat() {
+    }
+
+    static Entity seatOf(Entity rider) {
+        Entity root = rider.getRootVehicle();
+        return root instanceof SeatEntityEntity ? root : null;
+    }
+
+    /** Index of the radar target selected on the seat, 1 based, 0 for none. */
+    static int selectedTarget(Entity seat) {
+        return seat.getEntityData().get(SeatEntityEntity.DATA_SelectedTarget);
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/flight/AeroState.java

@@ -27,6 +27,7 @@ public final class AeroState implements PhysicsBridge.Publishable {
     private static final double INPUT_RATE_PER_TICK = 0.2;
     private static final double VELOCITY_EPSILON = 0.05;
     private static final double ANGULAR_EPSILON = 0.005;
+    private static final ControlAxis[] MEASURED_AXES = {ControlAxis.PITCH, ControlAxis.YAW, ControlAxis.ROLL};
 
     private final SubstepClock clock;
 
@@ -57,9 +58,22 @@ public final class AeroState implements PhysicsBridge.Publishable {
         // Torque (ship axes) one unit of pitch input on this node's pitch surfaces makes, measured every substep
         final Vector3d pitchResponse = new Vector3d();
         final Vector3d pitchResponseBuilding = new Vector3d();
+        // The same for yaw and roll, measured while cursor aim flies the node
+        final Vector3d yawResponse = new Vector3d();
+        final Vector3d yawResponseBuilding = new Vector3d();
+        final Vector3d rollResponse = new Vector3d();
+        final Vector3d rollResponseBuilding = new Vector3d();
         final AutoTrim.Targets trimTargets = new AutoTrim.Targets();
         volatile double savedTrim;
 
+        Vector3d responseBuilding(ControlAxis axis) {
+            return switch (axis) {
+                case YAW -> yawResponseBuilding;
+                case ROLL -> rollResponseBuilding;
+                default -> pitchResponseBuilding;
+            };
+        }
+
         NodeState(NodeData data) {
             pitch = data.pitch();
             yaw = data.yaw();
@@ -211,6 +225,8 @@ public final class AeroState implements PhysicsBridge.Publishable {
             wingStalled = false;
             for (NodeState state : nodeStates.values()) {
                 state.pitchResponseBuilding.zero();
+                state.yawResponseBuilding.zero();
+                state.rollResponseBuilding.zero();
             }
         }
 
@@ -221,7 +237,7 @@ public final class AeroState implements PhysicsBridge.Publishable {
             r[2] = s.z() - centerOfMass.z();
             NodeData node = s.node() != AeroSurface.NO_NODE ? frame.nodes.get(s.node()) : null;
             NodeState state = node != null ? nodeStates.get(node.key()) : null;
-            double input = s.type().controllable ? input(s, node, state, 0.0) : 0.0;
+            double input = s.type().controllable ? input(s, node, state, ControlAxis.NONE, 0.0) : 0.0;
 
             if (improved) {
                 boolean nowStalled = ImprovedAero.evaluate(s, v, w, r, input, weight, tuning, stalled[i], out);
@@ -233,53 +249,62 @@ public final class AeroState implements PhysicsBridge.Publishable {
                 WariumAero.evaluate(s, v, w, r, input, weight, out);
             }
 
-            // How much a little more pitch input on this node would change the torque, for auto trim
+            // How much a little more input on an axis would change the torque: pitch for auto trim, all three for
-            if (commit && node != null && node.autoTrim() && s.type().controllable && s.listensToPitch()) {
+            // cursor aim
-                double delta = 0.05;
+            if (commit && node != null && s.type().controllable) {
-                probe.clear();
+                boolean aimed = CursorAimRegistry.isActive(node.key());
-                double base = 0.0;
+                for (ControlAxis axis : MEASURED_AXES) {
-                if (improved) {
+                    if (!s.listensTo(axis) || !(aimed || (axis == ControlAxis.PITCH && node.autoTrim()))) {
-                    ImprovedAero.evaluate(s, v, w, r, input, weight, tuning, stalled[i], probe);
+                        continue;
-                } else {
+                    }
-                    WariumAero.evaluate(s, v, w, r, input, weight, probe);
+                    double delta = 0.05;
+                    probe.clear();
+                    if (improved) {
+                        ImprovedAero.evaluate(s, v, w, r, input, weight, tuning, stalled[i], probe);
+                    } else {
+                        WariumAero.evaluate(s, v, w, r, input, weight, probe);
+                    }
+                    double[] before = {probe.totalTorque(0), probe.totalTorque(1), probe.totalTorque(2)};
+                    probe.clear();
+                    double nudged = input(s, node, state, axis, delta);
+                    if (improved) {
+                        ImprovedAero.evaluate(s, v, w, r, nudged, weight, tuning, stalled[i], probe);
+                    } else {
+                        WariumAero.evaluate(s, v, w, r, nudged, weight, probe);
+                    }
+                    state.responseBuilding(axis).add(
+                            (probe.totalTorque(0) - before[0]) / delta,
+                            (probe.totalTorque(1) - before[1]) / delta,
+                            (probe.totalTorque(2) - before[2]) / delta);
                 }
-                double[] before = {probe.totalTorque(0), probe.totalTorque(1), probe.totalTorque(2)};
-                probe.clear();
-                double nudged = input(s, node, state, delta);
-                if (improved) {
-                    ImprovedAero.evaluate(s, v, w, r, nudged, weight, tuning, stalled[i], probe);
-                } else {
-                    WariumAero.evaluate(s, v, w, r, nudged, weight, probe);
-                }
-                state.pitchResponseBuilding.add(
-                        (probe.totalTorque(0) - before[0]) / delta,
-                        (probe.totalTorque(1) - before[1]) / delta,
-                        (probe.totalTorque(2) - before[2]) / delta);
             }
         }
 
         if (commit) {
             for (NodeState state : nodeStates.values()) {
                 state.pitchResponse.set(state.pitchResponseBuilding);
+                state.yawResponse.set(state.yawResponseBuilding);
+                state.rollResponse.set(state.rollResponseBuilding);
             }
         }
     }
 
     /** A control surface's input, combined from its two keys and clamped like Warium does. */
-    private static double input(AeroSurface s, NodeData node, NodeState state, double extraPitch) {
+    private static double input(AeroSurface s, NodeData node, NodeState state, ControlAxis nudged, double extra) {
         if (node == null || state == null) {
             return 0.0;
         }
-        double value = axisValue(s.axis1(), node, state, extraPitch) * s.multiplier1()
+        double value = axisValue(s.axis1(), node, state, nudged, extra) * s.multiplier1()
-                + axisValue(s.axis2(), node, state, extraPitch) * s.multiplier2();
+                + axisValue(s.axis2(), node, state, nudged, extra) * s.multiplier2();
         return Math.max(-1.0, Math.min(1.0, value));
     }
 
-    private static double axisValue(ControlAxis axis, NodeData node, NodeState state, double extraPitch) {
+    private static double axisValue(ControlAxis axis, NodeData node, NodeState state, ControlAxis nudged, double extra) {
+        double nudge = axis == nudged ? extra : 0.0;
         return switch (axis) {
-            case PITCH -> state.pitch + state.trimOutput + extraPitch;
+            case PITCH -> state.pitch + state.trimOutput + nudge;
-            case YAW -> state.yaw;
+            case YAW -> state.yaw + nudge;
-            case ROLL -> state.roll;
+            case ROLL -> state.roll + nudge;
             case THROTTLE -> node.throttle();
             case NONE -> 0.0;
         };
@@ -293,10 +318,12 @@ public final class AeroState implements PhysicsBridge.Publishable {
             if (state == null) {
                 continue;
             }
-            state.pitch = moveTowards(state.pitch, node.pitch(), step);
+            // Cursor aim, if the pilot has it on, supplies the inputs the pilot is not giving with the keys
-            state.yaw = moveTowards(state.yaw, node.yaw(), step);
+            NodeData effective = CursorPilot.apply(state, node, rotation, inertia, w, worldVelocity.length(), wingStalled);
-            state.roll = moveTowards(state.roll, node.roll(), step);
+            state.pitch = moveTowards(state.pitch, effective.pitch(), step);
-            AutoTrim.update(state, node, worldVelocity, altitude, rotation, inertia, w, dt, improved && wingStalled);
+            state.yaw = moveTowards(state.yaw, effective.yaw(), step);
+            state.roll = moveTowards(state.roll, effective.roll(), step);
+            AutoTrim.update(state, effective, worldVelocity, altitude, rotation, inertia, w, dt, improved && wingStalled);
         }
     }
 

src/main/java/dev/lumareth/improvedAerodynamics/flight/AeroSurface.java

@@ -36,6 +36,10 @@ public record AeroSurface(long key, SurfaceType type, boolean slab, double x, do
     }
 
     boolean listensToPitch() {
-        return node != NO_NODE && (axis1 == ControlAxis.PITCH || axis2 == ControlAxis.PITCH);
+        return listensTo(ControlAxis.PITCH);
+    }
+
+    boolean listensTo(ControlAxis axis) {
+        return node != NO_NODE && (axis1 == axis || axis2 == axis);
     }
 }

src/main/java/dev/lumareth/improvedAerodynamics/flight/AimBasis.java

@@ -0,0 +1,101 @@
+package dev.lumareth.improvedAerodynamics.flight;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.DirectionProperty;
+import net.minecraft.world.level.block.state.properties.Property;
+
+/**
+ * The frame cursor aim steers in, in ship coordinates: forward is the boresight (what Warium's gun reticle points
+ * along, from the HUD block in front of the seat, else the way the seat faces), up is the ship's up axis and right
+ * completes it. Server and client both build it from the same block data, so a cursor sent as components in this
+ * frame means the same on both.
+ *
+ * @param nodePos the Vehicle Control Node the seat is linked to
+ */
+public record AimBasis(BlockPos seatPos, BlockPos nodePos, double[] forward, double[] right, double[] up) {
+
+    /**
+     * @param entityPos block position of the seat entity. Warium's control seat block is at that position or just
+     *                  below it.
+     * @return null if there is no seat block linked to a control node there
+     */
+    public static AimBasis of(Level level, BlockPos entityPos) {
+        for (BlockPos pos : new BlockPos[]{entityPos, entityPos.below()}) {
+            BlockEntity seat = level.getBlockEntity(pos);
+            if (seat == null || !seat.getPersistentData().contains("ControlX")) {
+                continue;
+            }
+            CompoundTag tag = seat.getPersistentData();
+            BlockPos nodePos = BlockPos.containing(tag.getDouble("ControlX"), tag.getDouble("ControlY"), tag.getDouble("ControlZ"));
+            return new AimBasis(pos, nodePos, null, null, null).withAxes(level, pos, nodePos);
+        }
+        return null;
+    }
+
+    private AimBasis withAxes(Level level, BlockPos seatPos, BlockPos nodePos) {
+        BlockState state = level.getBlockState(seatPos);
+        Direction facing = Direction.NORTH;
+        Property<?> property = state.getBlock().getStateDefinition().getProperty("facing");
+        if (property instanceof DirectionProperty directionProperty) {
+            facing = state.getValue(directionProperty);
+        }
+        double fx = facing.getStepX();
+        double fy = facing.getStepY();
+        double fz = facing.getStepZ();
+
+        // Warium's gun reticle: the HUD block in front of the seat holds the aim vector of its guns
+        BlockEntity hud = level.getBlockEntity(seatPos.relative(facing));
+        if (hud != null && hud.getPersistentData().contains("Pitch")) {
+            CompoundTag hudTag = hud.getPersistentData();
+            double bx = hudTag.getDouble("X") + facing.getStepX();
+            double by = hudTag.getDouble("Pitch");
+            double bz = hudTag.getDouble("Z") + facing.getStepZ();
+            if (bx * bx + by * by + bz * bz > 1.0E-6) {
+                fx = bx;
+                fy = by;
+                fz = bz;
+            }
+        }
+        double length = Math.sqrt(fx * fx + fy * fy + fz * fz);
+        if (length < 1.0E-6) {
+            fx = 0.0;
+            fy = 0.0;
+            fz = -1.0;
+            length = 1.0;
+        }
+        fx /= length;
+        fy /= length;
+        fz /= length;
+
+        // right = forward x up(0,1,0)
+        double rx = -fz;
+        double ry = 0.0;
+        double rz = fx;
+        double rl = Math.sqrt(rx * rx + rz * rz);
+        if (rl < 1.0E-6) {
+            rx = 1.0;
+            rz = 0.0;
+            rl = 1.0;
+        }
+        rx /= rl;
+        rz /= rl;
+        // up = right x forward
+        double ux = ry * fz - rz * fy;
+        double uy = rz * fx - rx * fz;
+        double uz = rx * fy - ry * fx;
+        return new AimBasis(seatPos, nodePos, new double[]{fx, fy, fz}, new double[]{rx, ry, rz}, new double[]{ux, uy, uz});
+    }
+
+    /** Ship-space direction of a cursor given by its components along forward, right and up. */
+    public double[] toShip(double cf, double cr, double cu) {
+        return new double[]{
+                forward[0] * cf + right[0] * cr + up[0] * cu,
+                forward[1] * cf + right[1] * cr + up[1] * cu,
+                forward[2] * cf + right[2] * cr + up[2] * cu};
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/flight/ControlMode.java

@@ -0,0 +1,45 @@
+package dev.lumareth.improvedAerodynamics.flight;
+
+import dev.lumareth.improvedAerodynamics.network.ControlModePacket;
+import dev.lumareth.improvedAerodynamics.network.Network;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.player.Player;
+import net.minecraftforge.event.entity.player.PlayerEvent;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.network.PacketDistributor;
+
+/**
+ * How a player flies: with the keyboard (Warium's own seat controls) or with cursor aim. Chosen per player with
+ * {@code /aero controls}, kept in the player's persistent data and told to their client, which does the rest.
+ */
+public final class ControlMode {
+    private static final String KEY = "improved_aerodynamics_cursor_aim";
+
+    private ControlMode() {
+    }
+
+    public static boolean isCursorAim(ServerPlayer player) {
+        CompoundTag persisted = player.getPersistentData().getCompound(Player.PERSISTED_NBT_TAG);
+        return persisted.getBoolean(KEY);
+    }
+
+    public static void set(ServerPlayer player, boolean cursorAim) {
+        CompoundTag data = player.getPersistentData();
+        CompoundTag persisted = data.getCompound(Player.PERSISTED_NBT_TAG);
+        persisted.putBoolean(KEY, cursorAim);
+        data.put(Player.PERSISTED_NBT_TAG, persisted);
+        sync(player);
+    }
+
+    public static void sync(ServerPlayer player) {
+        Network.CHANNEL.send(PacketDistributor.PLAYER.with(() -> player), new ControlModePacket(isCursorAim(player)));
+    }
+
+    @SubscribeEvent
+    public static void onLogin(PlayerEvent.PlayerLoggedInEvent event) {
+        if (event.getEntity() instanceof ServerPlayer player) {
+            sync(player);
+        }
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/flight/CursorAimConfig.java

@@ -0,0 +1,56 @@
+package dev.lumareth.improvedAerodynamics.flight;
+
+import net.minecraftforge.common.ForgeConfigSpec;
+
+/** Server side settings of the cursor aim virtual pilot. Lives in improved_aerodynamics-cursor-aim.toml. */
+public final class CursorAimConfig {
+    public static final ForgeConfigSpec SPEC;
+
+    public static final ForgeConfigSpec.BooleanValue ENABLED;
+    public static final ForgeConfigSpec.DoubleValue FULL_DEFLECTION_DEGREES;
+    public static final ForgeConfigSpec.DoubleValue DEADZONE_DEGREES;
+    public static final ForgeConfigSpec.DoubleValue MAX_TURN_RATE_DEGREES;
+    public static final ForgeConfigSpec.DoubleValue MAX_ROLL_RATE_DEGREES;
+    public static final ForgeConfigSpec.DoubleValue MAX_BANK_DEGREES;
+    public static final ForgeConfigSpec.DoubleValue BANK_GAIN;
+    public static final ForgeConfigSpec.DoubleValue RATE_GAIN;
+    public static final ForgeConfigSpec.DoubleValue PUSH_FACTOR;
+    public static final ForgeConfigSpec.DoubleValue STALLED_PITCH_FACTOR;
+    public static final ForgeConfigSpec.DoubleValue MIN_SPEED;
+
+    static {
+        ForgeConfigSpec.Builder builder = new ForgeConfigSpec.Builder();
+        builder.comment("Cursor aim: the mouse moves a cursor on screen, a virtual pilot flies the control node's craft by it").push("cursor_aim");
+        ENABLED = builder.comment("Whether pilots may use cursor aim on this server")
+                .define("enabled", true);
+        FULL_DEFLECTION_DEGREES = builder.comment("Angle of the cursor from the gun reticle at which the virtual pilot asks for full deflection: the maximum bank",
+                        "sideways, the full pitch rate up or down")
+                .defineInRange("fullDeflectionDegrees", 30.0, 5.0, 90.0);
+        DEADZONE_DEGREES = builder.comment("Radius around the gun reticle in degrees inside which the cursor commands nothing, so the craft flies straight.",
+                        "Outside it the command grows from zero, there is no jump at the edge")
+                .defineInRange("deadzoneDegrees", 3.0, 0.0, 15.0);
+        MAX_TURN_RATE_DEGREES = builder.comment("Turn rate in degrees per second the pilot asks for at full deflection, both for the turn at maximum bank and for pitching")
+                .defineInRange("maxTurnRateDegrees", 40.0, 5.0, 360.0);
+        MAX_ROLL_RATE_DEGREES = builder.comment("Fastest roll in degrees per second the pilot asks for when it rolls to a bank angle")
+                .defineInRange("maxRollRateDegrees", 150.0, 10.0, 720.0);
+        MAX_BANK_DEGREES = builder.comment("Bank angle the pilot rolls to when the cursor is at full sideways deflection")
+                .defineInRange("maxBankDegrees", 70.0, 10.0, 90.0);
+        BANK_GAIN = builder.comment("Roll rate in rad/s per radian of bank angle error, how eagerly the pilot rolls to the wanted bank and levels the wings")
+                .defineInRange("bankGain", 3.0, 0.2, 20.0);
+        RATE_GAIN = builder.comment("How hard the pilot corrects its turn rate, in angular acceleration per rad/s of rate error. Lower is smoother,",
+                        "higher follows the cursor tighter and can start to oscillate")
+                .defineInRange("rateGain", 5.0, 0.5, 40.0);
+        PUSH_FACTOR = builder.comment("A cursor below the gun reticle pushes the nose down. This is how much of the pull rate that may be, since",
+                        "negative g is harder on the craft and the pilot")
+                .defineInRange("pushFactor", 0.4, 0.0, 1.0);
+        STALLED_PITCH_FACTOR = builder.comment("Multiplier for the pitch rate the pilot asks for while the wings are stalled, so it does not keep pulling")
+                .defineInRange("stalledPitchFactor", 0.3, 0.0, 1.0);
+        MIN_SPEED = builder.comment("Below this speed in blocks per second the pilot does nothing, the surfaces have no effect anyway")
+                .defineInRange("minSpeed", 15.0, 0.0, 200.0);
+        builder.pop();
+        SPEC = builder.build();
+    }
+
+    private CursorAimConfig() {
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/flight/CursorAimRegistry.java

@@ -0,0 +1,44 @@
+package dev.lumareth.improvedAerodynamics.flight;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Where each control node's pilot currently holds the cursor of cursor aim. Written by the server thread when the
+ * client's packet arrives, read by the physics thread. An entry that is not refreshed for a moment (the player left
+ * the seat, lost the connection) counts as gone.
+ */
+public final class CursorAimRegistry {
+    private static final long EXPIRE_NANOS = 500_000_000L;
+    private static final ConcurrentHashMap<Long, Aim> AIMS = new ConcurrentHashMap<>();
+
+    /** Cursor as components along the basis axes (unit length), and the basis itself, in ship space. */
+    public record Aim(double cf, double cr, double cu, double[] forward, double[] right, double[] up, long nanos) {
+    }
+
+    private CursorAimRegistry() {
+    }
+
+    public static void set(long nodeKey, Aim aim) {
+        AIMS.put(nodeKey, aim);
+    }
+
+    public static void clear(long nodeKey) {
+        AIMS.remove(nodeKey);
+    }
+
+    public static Aim get(long nodeKey) {
+        Aim aim = AIMS.get(nodeKey);
+        if (aim == null) {
+            return null;
+        }
+        if (System.nanoTime() - aim.nanos() > EXPIRE_NANOS) {
+            AIMS.remove(nodeKey, aim);
+            return null;
+        }
+        return aim;
+    }
+
+    public static boolean isActive(long nodeKey) {
+        return get(nodeKey) != null;
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/flight/CursorAimServer.java

@@ -0,0 +1,34 @@
+package dev.lumareth.improvedAerodynamics.flight;
+
+import net.mcreator.valkyrienwarium.entity.SeatEntityEntity;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.Entity;
+
+/** Server side of cursor aim: takes the cursor a pilot sends and hands it to the control node's virtual pilot. */
+public final class CursorAimServer {
+    private CursorAimServer() {
+    }
+
+    public static void accept(ServerPlayer player, boolean active, double cf, double cr, double cu) {
+        // Only a player who chose cursor aim may set or clear the cursor of a node
+        if (!ControlMode.isCursorAim(player)) {
+            return;
+        }
+        Entity vehicle = player.getVehicle();
+        if (!(vehicle instanceof SeatEntityEntity)) {
+            return;
+        }
+        AimBasis basis = AimBasis.of(vehicle.level(), vehicle.blockPosition());
+        if (basis == null) {
+            return;
+        }
+        long nodeKey = basis.nodePos().asLong();
+        double length = Math.sqrt(cf * cf + cr * cr + cu * cu);
+        if (!active || !CursorAimConfig.ENABLED.get() || !(length > 1.0E-6) || !Double.isFinite(length)) {
+            CursorAimRegistry.clear(nodeKey);
+            return;
+        }
+        CursorAimRegistry.set(nodeKey, new CursorAimRegistry.Aim(cf / length, cr / length, cu / length,
+                basis.forward(), basis.right(), basis.up(), System.nanoTime()));
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/flight/CursorPilot.java

@@ -0,0 +1,144 @@
+package dev.lumareth.improvedAerodynamics.flight;
+
+import org.joml.Matrix3d;
+import org.joml.Matrix3dc;
+import org.joml.Quaterniondc;
+import org.joml.Vector3d;
+
+/**
+ * The virtual pilot of cursor aim. The cursor is a stick that springs back to the gun reticle:
+ * <ul>
+ *   <li>sideways it commands a bank angle and turn: the further out, the steeper the bank and the harder the pull
+ *   that comes with it. Centered it levels the wings, so a centered cursor is straight flight;</li>
+ *   <li>up and down it commands a pitch rate;</li>
+ *   <li>close to the reticle it steers with yaw and pitch directly instead of banking, so aiming does not rock the
+ *   wings.</li>
+ * </ul>
+ * The wanted rotation is turned into stick inputs by the measured effect of each input on the craft (torque per unit
+ * of input, see {@link AeroState}), so it works for any craft however its surfaces are mixed or oriented: angular
+ * acceleration wanted times inertia, solved for the three inputs with a little regularization for axes that have no
+ * surfaces. Keys the pilot holds win over it, per axis.
+ */
+final class CursorPilot {
+    private static final double FINE_START = Math.toRadians(4.0);
+    private static final double FINE_END = Math.toRadians(16.0);
+    private static final double MANUAL_OVERRIDE = 0.05;
+    private static final double MAX_PULL_BANK = Math.toRadians(90.0);
+
+    private CursorPilot() {
+    }
+
+    /**
+     * @return the node with the pilot's wanted inputs in place of the keys, or the node itself if cursor aim is off
+     */
+    static NodeData apply(AeroState.NodeState state, NodeData node, Quaterniondc rotation, Matrix3dc inertia, double[] w,
+                          double speed, boolean wingStalled) {
+        if (!CursorAimConfig.ENABLED.get()) {
+            return node;
+        }
+        CursorAimRegistry.Aim aim = CursorAimRegistry.get(node.key());
+        if (aim == null || speed < CursorAimConfig.MIN_SPEED.get()) {
+            return node;
+        }
+
+        double fullAngle = Math.toRadians(CursorAimConfig.FULL_DEFLECTION_DEGREES.get());
+        double maxTurn = Math.toRadians(CursorAimConfig.MAX_TURN_RATE_DEGREES.get());
+        double maxRoll = Math.toRadians(CursorAimConfig.MAX_ROLL_RATE_DEGREES.get());
+        double maxBank = Math.toRadians(CursorAimConfig.MAX_BANK_DEGREES.get());
+
+        double[] f = aim.forward();
+        double[] r = aim.right();
+        double[] u = aim.up();
+
+        // Cursor as angles from the reticle: sideways (positive right) and up, both through any 270 degree cone
+        double sideways = Math.atan2(aim.cr(), aim.cf());
+        double vertical = Math.atan2(aim.cu(), Math.hypot(aim.cf(), aim.cr()));
+        // Deadzone around the reticle: shrink the cursor offset by its radius, direction kept
+        double offset = Math.hypot(sideways, vertical);
+        double deadzone = Math.toRadians(CursorAimConfig.DEADZONE_DEGREES.get());
+        if (offset > 1.0E-9) {
+            double scale = Math.max(0.0, offset - deadzone) / offset;
+            sideways *= scale;
+            vertical *= scale;
+        }
+        double lateral = saturate(sideways / fullAngle);
+        double blend = smoothstep(Math.abs(sideways), FINE_START, FINE_END);
+
+        // Bank of the craft: positive when the right wing is down, through upside down
+        Vector3d rightWorld = rotation.transform(new Vector3d(r[0], r[1], r[2]));
+        Vector3d upWorld = rotation.transform(new Vector3d(u[0], u[1], u[2]));
+        double bank = Math.atan2(-rightWorld.y, upWorld.y);
+
+        double bankCommand = maxBank * lateral * blend;
+        double rollRate = clamp(CursorAimConfig.BANK_GAIN.get() * (bankCommand - bank), -maxRoll, maxRoll);
+
+        // Pitch: the stick, plus the pull that carries the turn while banked
+        double pitchStick = saturate(vertical / fullAngle);
+        double pitchRate = maxTurn * (pitchStick >= 0.0 ? pitchStick : pitchStick * CursorAimConfig.PUSH_FACTOR.get());
+        if (Math.abs(bank) < MAX_PULL_BANK) {
+            pitchRate += maxTurn * Math.abs(lateral) * blend * Math.sin(Math.abs(bank));
+        }
+        if (wingStalled && pitchRate > 0.0) {
+            pitchRate *= CursorAimConfig.STALLED_PITCH_FACTOR.get();
+        }
+        // Close to the reticle the nose follows the cursor with the rudder
+        double yawRate = maxTurn * lateral * (1.0 - blend);
+
+        // Wanted angular velocity in ship axes: roll about forward, pitch about right, yaw (nose right) about -up
+        Vector3d wanted = new Vector3d(
+                rollRate * f[0] + pitchRate * r[0] - yawRate * u[0],
+                rollRate * f[1] + pitchRate * r[1] - yawRate * u[1],
+                rollRate * f[2] + pitchRate * r[2] - yawRate * u[2]);
+        Vector3d error = wanted.sub(w[0], w[1], w[2]);
+        Vector3d acceleration = error.mul(CursorAimConfig.RATE_GAIN.get());
+        Vector3d torque = inertia.transform(acceleration, new Vector3d());
+
+        double[] inputs = solve(state.pitchResponse, state.yawResponse, state.rollResponse, torque);
+        if (inputs == null) {
+            return node;
+        }
+
+        double pitch = clamp(inputs[0] - state.trimOutput, -1.0, 1.0);
+        double yaw = clamp(inputs[1], -1.0, 1.0);
+        double roll = clamp(inputs[2], -1.0, 1.0);
+        return new NodeData(node.key(),
+                Math.abs(node.pitch()) > MANUAL_OVERRIDE ? node.pitch() : pitch,
+                Math.abs(node.yaw()) > MANUAL_OVERRIDE ? node.yaw() : yaw,
+                Math.abs(node.roll()) > MANUAL_OVERRIDE ? node.roll() : roll,
+                node.throttle(), node.autoTrim(), node.storedTrim());
+    }
+
+    /** Least squares for the three inputs whose responses add up to the torque, ridge-regularized so unused axes stay at zero. */
+    private static double[] solve(Vector3d pitch, Vector3d yaw, Vector3d roll, Vector3d torque) {
+        Matrix3d responses = new Matrix3d(pitch, yaw, roll);
+        Matrix3d transposed = responses.transpose(new Matrix3d());
+        Matrix3d normal = transposed.mul(responses, new Matrix3d());
+        double trace = normal.m00() + normal.m11() + normal.m22();
+        if (!(trace > 1.0E-9) || !Double.isFinite(trace)) {
+            return null;
+        }
+        double ridge = trace / 3.0 * 1.0E-3;
+        normal.m00(normal.m00() + ridge);
+        normal.m11(normal.m11() + ridge);
+        normal.m22(normal.m22() + ridge);
+        Vector3d right = transposed.transform(torque, new Vector3d());
+        Vector3d x = normal.invert().transform(right);
+        if (!x.isFinite()) {
+            return null;
+        }
+        return new double[]{x.x, x.y, x.z};
+    }
+
+    private static double saturate(double value) {
+        return clamp(value, -1.0, 1.0);
+    }
+
+    private static double smoothstep(double value, double from, double to) {
+        double t = clamp((value - from) / (to - from), 0.0, 1.0);
+        return t * t * (3.0 - 2.0 * t);
+    }
+
+    private static double clamp(double value, double min, double max) {
+        return Math.max(min, Math.min(max, value));
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/network/AimPacket.java

@@ -0,0 +1,45 @@
+package dev.lumareth.improvedAerodynamics.network;
+
+import dev.lumareth.improvedAerodynamics.flight.CursorAimServer;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraftforge.fml.ModList;
+import net.minecraftforge.network.NetworkEvent;
+
+import java.util.function.Supplier;
+
+/**
+ * Sent every tick while a pilot has cursor aim on, and once when it goes off. The cursor is given as components along
+ * the craft's boresight, right and up axes, so it does not depend on the camera.
+ */
+public final class AimPacket {
+    private final boolean active;
+    private final float forward;
+    private final float right;
+    private final float up;
+
+    public AimPacket(boolean active, float forward, float right, float up) {
+        this.active = active;
+        this.forward = forward;
+        this.right = right;
+        this.up = up;
+    }
+
+    public void encode(FriendlyByteBuf buffer) {
+        buffer.writeBoolean(active);
+        buffer.writeFloat(forward);
+        buffer.writeFloat(right);
+        buffer.writeFloat(up);
+    }
+
+    public static AimPacket decode(FriendlyByteBuf buffer) {
+        return new AimPacket(buffer.readBoolean(), buffer.readFloat(), buffer.readFloat(), buffer.readFloat());
+    }
+
+    public void handle(Supplier<NetworkEvent.Context> context) {
+        ServerPlayer player = context.get().getSender();
+        if (player != null && ModList.get().isLoaded("valkyrien_warium")) {
+            CursorAimServer.accept(player, active, forward, right, up);
+        }
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/network/ControlModePacket.java

@@ -0,0 +1,32 @@
+package dev.lumareth.improvedAerodynamics.network;
+
+import dev.lumareth.improvedAerodynamics.client.aim.CursorAimClient;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.fml.DistExecutor;
+import net.minecraftforge.network.NetworkEvent;
+
+import java.util.function.Supplier;
+
+/** Tells a client whether its player flies with cursor aim, see {@code /aero controls}. */
+public final class ControlModePacket {
+    private final boolean cursorAim;
+
+    public ControlModePacket(boolean cursorAim) {
+        this.cursorAim = cursorAim;
+    }
+
+    public void encode(FriendlyByteBuf buffer) {
+        buffer.writeBoolean(cursorAim);
+    }
+
+    public static ControlModePacket decode(FriendlyByteBuf buffer) {
+        return new ControlModePacket(buffer.readBoolean());
+    }
+
+    public void handle(Supplier<NetworkEvent.Context> context) {
+        boolean value = cursorAim;
+        DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> CursorAimClient.setMode(value));
+        context.get().setPacketHandled(true);
+    }
+}

src/main/java/dev/lumareth/improvedAerodynamics/network/Network.java

@@ -23,5 +23,16 @@ public final class Network {
                 .decoder(ToggleAutoTrimPacket::decode)
                 .consumerMainThread(ToggleAutoTrimPacket::handle)
                 .add();
+        // High id so it cannot collide with packets added on other branches
+        CHANNEL.messageBuilder(AimPacket.class, 50, NetworkDirection.PLAY_TO_SERVER)
+                .encoder(AimPacket::encode)
+                .decoder(AimPacket::decode)
+                .consumerMainThread(AimPacket::handle)
+                .add();
+        CHANNEL.messageBuilder(ControlModePacket.class, 51, NetworkDirection.PLAY_TO_CLIENT)
+                .encoder(ControlModePacket::encode)
+                .decoder(ControlModePacket::decode)
+                .consumerMainThread(ControlModePacket::handle)
+                .add();
     }
 }

src/main/resources/assets/improved_aerodynamics/lang/de_de.json

@@ -12,5 +12,10 @@
   "config.improved_aerodynamics.supersonicDrag": "Multiplikator für den Nullauftriebswiderstand bei vollem Überschall, ab Mach 1,3",
   "config.improved_aerodynamics.vortexLift": "Wirbelauftrieb: Flügel mit kleiner Streckung (Deltaflügel) überziehen später und liefern bei großen Anstellwinkeln mehr Auftrieb (verbessertes Flugmodell)",
   "config.improved_aerodynamics.vortexStallBonus": "Zusätzlicher Überziehwinkel der Flügel mit der kleinsten Streckung, als Anteil des normalen Überziehwinkels",
-  "config.improved_aerodynamics.vortexLiftStrength": "Multiplikator für den zusätzlichen Auftrieb der Vorderkantenwirbel"
+  "config.improved_aerodynamics.vortexLiftStrength": "Multiplikator für den zusätzlichen Auftrieb der Vorderkantenwirbel",
+  "key.improved_aerodynamics.cursor_aim_free_look": "Cursor-Steuerung: Freie Sicht (halten)",
+  "message.improved_aerodynamics.cursor_aim.on": "Cursor-Steuerung an",
+  "message.improved_aerodynamics.cursor_aim.off": "Cursor-Steuerung aus",
+  "message.improved_aerodynamics.cursor_aim.no_seat": "Setz dich in einen Warium-Steuersitz, um die Cursor-Steuerung zu nutzen",
+  "message.improved_aerodynamics.cursor_aim.no_server": "Dieser Server hat Improved Aerodynamics nicht, die Cursor-Steuerung braucht es"
 }

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

@@ -12,5 +12,10 @@
   "config.improved_aerodynamics.supersonicDrag": "Zero-lift drag multiplier once fully supersonic, from Mach 1.3",
   "config.improved_aerodynamics.vortexLift": "Vortex lift: low aspect ratio (delta) wings stall later and lift more at high angles of attack (improved flight model)",
   "config.improved_aerodynamics.vortexStallBonus": "Extra stall angle of the lowest aspect ratio wings, as a fraction of the normal stall angle",
-  "config.improved_aerodynamics.vortexLiftStrength": "Multiplier for the extra lift the leading-edge vortices make"
+  "config.improved_aerodynamics.vortexLiftStrength": "Multiplier for the extra lift the leading-edge vortices make",
+  "key.improved_aerodynamics.cursor_aim_free_look": "Cursor aim: free look (hold)",
+  "message.improved_aerodynamics.cursor_aim.on": "Cursor aim on",
+  "message.improved_aerodynamics.cursor_aim.off": "Cursor aim off",
+  "message.improved_aerodynamics.cursor_aim.no_seat": "Sit in a Warium control seat to use cursor aim",
+  "message.improved_aerodynamics.cursor_aim.no_server": "This server does not have Improved Aerodynamics, cursor aim needs it"
 }