Controlify v4

.gitignore

@@ -6,3 +6,5 @@ build
 .gradle
 !.gitkeep
 .kotlin
+
+.DS_Store

build.gradle.kts

@@ -57,9 +57,6 @@ dependencies {
     commonApi(libs.sdl.java.backend.ffm)
     commonInclude(libs.sdl.java.backend.ffm)
 
-    commonApi(libs.steamdeck4j)
-    commonInclude(libs.steamdeck4j)
-
     commonApi(libs.quilt.parsers.json)
 
     compileOnlyApi("dev.isxander:yet-another-config-lib:${property("dep.yacl")}") {
@@ -154,10 +151,10 @@ val commonManifest = manifests.manifest {
 
     mixin("controlify.mixins.json")
     mixin("controlify-compat.yacl.mixins.json")
-    ifPresent("deps.iris") { mixin("controlify-compat.iris.mixins.json") }
-    ifPresent("deps.sodium") { mixin("controlify-compat.sodium.mixins.json") }
-    ifPresent("deps.reeses-sodium-options") { mixin("controlify-compat.reeses-sodium-options.mixins.json") }
-    ifPresent("deps.svc") { mixin("controlify-compat.svc.mixins.json") }
+    ifPresent("dep.iris") { mixin("controlify-compat.iris.mixins.json") }
+    ifPresent("dep.sodium") { mixin("controlify-compat.sodium.mixins.json") }
+    ifPresent("dep.rso") { mixin("controlify-compat.reeses-sodium-options.mixins.json") }
+    ifPresent("dep.svc") { mixin("controlify-compat.simple-voice-chat.mixins.json") }
     mixin("controlify-compat.rrls.mixins.json")
 
     dependency("minecraft", REQUIRED, minecraftRange)
@@ -169,18 +166,24 @@ manifests {
             "controlify:default_config",
             "controlify:controller_type",
             "controlify:default_binds",
-            "controlify:trigger_effect",
+            "controlify:contextual/domain/in_game",
+            "controlify:contextual/domain/container",
+            "controlify:contextual/ruleset/guide",
+            "controlify:contextual/ruleset/trigger_effect",
+            "controlify:activators",
+            "controlify:controller_mapping",
+            "controlify:rumble_sources",
             "controlify:radial_icons",
         )
     ))
 
     fabricModJson(sourceSets.fabric.get()) {
         from(commonManifest)
 
-        entrypoint("modmenu", "dev.isxander.controlify.fabric.compatibility.ModMenuIntegration")
-        entrypoint("main", "dev.isxander.controlify.fabric.ControlifyBootstrap")
-        entrypoint("client", "dev.isxander.controlify.fabric.ControlifyBootstrap")
-        entrypoint("server", "dev.isxander.controlify.fabric.ControlifyBootstrap")
+        entrypoint("modmenu", "dev.isxander.controlify.fabric.compat.ModMenuIntegration")
+        entrypoint("main", "dev.isxander.controlify.fabric.impl.ControlifyBootstrap")
+        entrypoint("client", "dev.isxander.controlify.fabric.impl.ControlifyBootstrap")
+        entrypoint("server", "dev.isxander.controlify.fabric.impl.ControlifyBootstrap")
         dependency("fabricloader", REQUIRED, "[0.19,)")
 
         mixin("controlify-platform.fabric.mixins.json")
@@ -281,6 +284,18 @@ if (includeNatives) {
     }
 }
 
+// Run configs
+
+// Fabric
+loom.runConfigs.configureEach {
+	runDirectory = layout.projectDirectory.dir("run")
+}
+
+// NeoForge
+runs.configureEach {
+	workingDirectory = layout.projectDirectory.dir("run")
+}
+
 /// Testing
 
 fabricApi {

docs/.vitepress/config.ts

@@ -86,7 +86,8 @@ export default defineConfig({
           { text: 'Button Guides', link: '/resource-packs/guides' },
           { text: 'Keyboard Layouts', link: '/resource-packs/keyboard-layouts' },
           { text: 'Radial Menu Icons', link: '/resource-packs/radial-icons' },
-          { text: 'Adaptive Trigger Effects', link: '/resource-packs/adaptive-trigger-effects' }
+          { text: 'Adaptive Trigger Effects', link: '/resource-packs/adaptive-trigger-effects' },
+          { text: 'Feedback Effects', link: '/resource-packs/feedback-effects' }
         ]
       },
       {
@@ -97,7 +98,8 @@ export default defineConfig({
           { text: 'Controlify Entrypoint', link: '/developers/controlify-entrypoint' },
           { text: 'Bindings API', link: '/developers/bindings-api' },
           { text: 'Screen Operation API', link: '/developers/screen-operation-api' },
-          { text: 'Contextual API', link: '/developers/contextual-api' }
+          { text: 'Contextual API', link: '/developers/contextual-api' },
+          { text: 'Feedback API', link: '/developers/feedback-api' }
         ]
       },
 			{

docs/content/developers/feedback-api.md

@@ -0,0 +1,132 @@
+---
+title: Feedback API
+---
+
+# Feedback API
+
+Feedback is everything the player feels through the controller. The API splits it in two:
+
+- A `FeedbackEvent` says **when** something should be felt. Your code fires it.
+- A `FeedbackEffect` says **what** it feels like. This is usually a
+  [data file](../resource-packs/feedback-effects.md), so resource packs can change it.
+
+The API is in `dev.isxander.controlify.api.feedback` and is marked experimental.
+
+::: tip
+If the situation you want feedback for is already described by contextual state, you may not need any code. A
+[rule with no event](../resource-packs/feedback-effects.md#rules-with-no-event) plays an effect whenever a predicate is
+true.
+:::
+
+## Declaring an event
+
+Declare an event once and keep it in a static field. The params are a type of your own; each `param` call also exposes
+one of its numbers by name for data-driven effects.
+
+```java
+public record Recoil(float force) {}
+
+public static final FeedbackEvent<Recoil> RECOIL = FeedbackEvent.builder(Identifier.fromNamespaceAndPath("mymod", "recoil"))
+        .param("force", Recoil::force)
+        .build();
+
+// an event with no params
+public static final FeedbackEvent<Void> RELOAD = FeedbackEvent.builder(Identifier.fromNamespaceAndPath("mymod", "reload"))
+        .build();
+```
+
+Register events in your [Controlify entrypoint](controlify-entrypoint.md) so they appear in diagnostics:
+
+```java
+FeedbackEvents.REGISTER.subscribeForever(registry -> {
+    registry.registerEvent(RECOIL);
+    registry.registerEvent(RELOAD);
+});
+```
+
+## Firing and holding
+
+Emit sites hold no state. Events play on the current controller.
+
+```java
+// one-shot
+RECOIL.fire(new Recoil(0.8f));
+
+// one-shot at a position: it gets weaker with distance on its own
+RECOIL.fireAt(pos, new Recoil(0.8f));
+
+// continuous: call every tick while the condition is true
+if (charging) {
+    CHARGE.hold(new Charge(progress));
+}
+
+// optional: end a hold at once, instead of when the calls stop
+CHARGE.release();
+```
+
+A held event ends by itself about three ticks after you stop calling `hold`, so `release` is only for when it must
+stop immediately. Each `hold` call refreshes the params.
+
+With nothing else set up, an event plays the effect with its own id, so `mymod:recoil` plays
+`assets/mymod/controller/feedback/recoil.json`. If no such effect exists, firing it does nothing.
+
+## Effects in code
+
+Write the effect as a [data file](../resource-packs/feedback-effects.md) where you can. Use code for an effect that
+needs logic a data file cannot express.
+
+A code effect receives your params with their real type:
+
+```java
+FeedbackEvents.REGISTER.subscribeForever(registry -> {
+    registry.registerEffect(RECOIL, (playback, out) -> {
+        float force = playback.params().force();
+        float remaining = 1f - playback.seconds() / 0.2f;
+        if (remaining <= 0f) {
+            return false; // finished
+        }
+        out.rumble(force * remaining, force * 0.5f);
+        return true;
+    });
+});
+```
+
+- An effect is stateless. Everything about the playback is in `Playback`: `seconds()`, `params()`, `held()`,
+  `released()` and `sinceRelease()`.
+- Effects are sampled once per rendered frame, so work in seconds, not ticks.
+- Return `false` when the effect is over. An effect for a held event should return `false` once `released()` is true,
+  or after a tail of its own.
+- A data effect with the same id always wins over a code effect, so resource packs can still replace yours.
+
+`registerEffect(event, effect)` registers the event's default effect. To register a variant that
+[selection rules](../resource-packs/feedback-effects.md#rules-for-an-event) can choose, give it its own id:
+`registerEffect(id, event, effect)`. Mark the event with `.selection()` when you build it so its rules are consulted.
+
+### The output frame
+
+`FeedbackFrame` describes what should be felt without naming any hardware.
+
+| Method | Meaning |
+|--------|---------|
+| `band(site, band, amp)` | A rumble band (`LOW` or `HIGH`). Every controller can play this. |
+| `rumble(low, high)` | Both bands on the whole controller |
+| `voice(site, hz, amp)` | A tone at a frequency, for HD haptics |
+| `click(site, intensity, sharpness)` | A single transient |
+| `hd()` | Whether the controller reproduces voices and clicks faithfully |
+
+Call `click` once, on the frame it should happen. `playback.crossed(seconds)` is true for exactly one frame:
+
+```java
+if (playback.crossed(0.1f)) {
+    out.click(Site.BODY, 0.8f, 0.7f);
+}
+```
+
+How each controller plays a frame:
+
+| Controller | Bands | Voices | Clicks |
+|------------|-------|--------|--------|
+| Ordinary rumble | The two motors | Folded into the nearest band | A short burst |
+| Trigger motors | Trigger sites only | Amplitude only | A short burst |
+| DualSense (HD haptics on) | Synthesised tones | Synthesised at their frequency | A synthesised burst |
+| Steam Controller (2026) | The rumble motors | A tone command | A tick or click command |