Add a setting to adjust rumble intensity (or turn it off)

peterix · peterix · commit c5aba764d6d2 · 2025-07-23T19:19:34.000+02:00
diff --git a/src/audio/Adlib.zig b/src/audio/Adlib.zig
@@ -369,36 +369,38 @@ fn playTrack(ctx: *anyopaque, track: ?AudioTrack) void {
 fn triggerEvent(ctx: *anyopaque, event: GameEvent) void {
     const self: *Adlib = @ptrCast(@alignCast(ctx));
     switch (event) {
-        .Event_HitEnemy => {
+        .None => {},
+        .HitEnemy => {
             self.playSfx(1);
         },
-        .Event_HitPlayer => {
+        .HitPlayer => {
             self.playSfx(4);
         },
-        .Event_PlayerHeadImpact => {
+        .PlayerHeadImpact => {
             self.playSfx(5);
         },
-        .Event_PlayerPickup, .Event_PlayerPickupEnemy => {
+        .PlayerPickup, .PlayerPickupEnemy => {
             self.playSfx(9);
         },
-        .Event_PlayerThrow => {
+        .PlayerThrow => {
             self.playSfx(3);
         },
-        .Event_PlayerJump => {
+        .PlayerJump => {
             // Nothing here, but we could
         },
-        .Event_BallBounce => {
+        .BallBounce => {
             self.playSfx(12);
         },
-        .Event_PlayerCollectWaypoint => {
+        .PlayerCollectWaypoint => {
             self.playTrackNumber(5);
         },
-        .Event_PlayerCollectBonus => {
+        .PlayerCollectBonus => {
             self.playTrackNumber(6);
         },
-        .Event_PlayerCollectLamp => {
+        .PlayerCollectLamp => {
             self.playTrackNumber(7);
         },
+        .Options_TestRumble => {},
     }
 }
 
diff --git a/src/enemies.c b/src/enemies.c
@@ -1255,7 +1255,7 @@ void SET_NMI(TITUS_level *level) {
         }
       }
       // If final enemy, remove energy
-      playEvent_c(Event_HitEnemy);
+      playc(HitEnemy);
       DROP_FLAG = 0;
       if (level->enemy[i].boss) {
         if (INVULNERABLE_FLAG != 0) {
@@ -1342,7 +1342,7 @@ void ACTIONC_NMI(TITUS_level *level, TITUS_enemy *enemy) {
 }
 
 void KICK_ASH(TITUS_level *level, TITUS_sprite *enemysprite, int16_t power) {
-  playEvent_c(Event_HitPlayer);
+  playc(HitPlayer);
   TITUS_sprite *p_sprite = &(level->player.sprite);
   DEC_ENERGY(level);
   DEC_ENERGY(level);
diff --git a/src/enemies.zig b/src/enemies.zig
@@ -1151,7 +1151,7 @@ pub fn SET_NMI(level: *lvl.Level) void {
                     level.object[@as(c_ushort, @intCast(k))].sprite.speed_x = @as(i16, @bitCast(@as(c_short, @truncate(0 - @as(c_int, @bitCast(@as(c_int, level.object[@as(c_ushort, @intCast(k))].sprite.speed_x)))))));
                 }
             }
-            events.triggerEvent(.Event_HitEnemy);
+            events.triggerEvent(.HitEnemy);
             globals.DROP_FLAG = false;
             if (enemy.boss) {
                 if (@as(c_int, @bitCast(@as(c_uint, globals.INVULNERABLE_FLAG))) != 0) {
@@ -1223,7 +1223,7 @@ fn ACTIONC_NMI(level: *lvl.Level, enemy: *lvl.Enemy) void {
 }
 
 fn KICK_ASH(level: *lvl.Level, enemysprite: *lvl.Sprite, power: i16) void {
-    events.triggerEvent(.Event_HitPlayer);
+    events.triggerEvent(.HitPlayer);
     const p_sprite = &level.player.sprite;
 
     // about 2 seconds worth of invulnereability frames
diff --git a/src/events.zig b/src/events.zig
@@ -2,17 +2,19 @@ const audio = @import("audio/audio.zig");
 const input = @import("input.zig");
 
 pub const GameEvent = enum {
-    Event_HitEnemy,
-    Event_HitPlayer,
-    Event_PlayerHeadImpact,
-    Event_PlayerPickup,
-    Event_PlayerPickupEnemy,
-    Event_PlayerThrow,
-    Event_PlayerJump,
-    Event_BallBounce,
-    Event_PlayerCollectWaypoint,
-    Event_PlayerCollectBonus,
-    Event_PlayerCollectLamp,
+    None,
+    HitEnemy,
+    HitPlayer,
+    PlayerHeadImpact,
+    PlayerPickup,
+    PlayerPickupEnemy,
+    PlayerThrow,
+    PlayerJump,
+    BallBounce,
+    PlayerCollectWaypoint,
+    PlayerCollectBonus,
+    PlayerCollectLamp,
+    Options_TestRumble,
 };
 
 pub fn triggerEvent(event: GameEvent) void {
diff --git a/src/input.zig b/src/input.zig
@@ -58,6 +58,16 @@ pub fn setInputMode(input_mode: InputMode) void {
     // FIXME: save the file
 }
 
+pub fn getRumble() u8 {
+    return game.settings.rumble;
+}
+
+pub fn setRumble(rumble: u8) void {
+    game.settings.rumble = rumble;
+    // FIXME: save the file
+}
+
+
 pub const InputAction = enum {
     None,
     Quit,
@@ -121,8 +131,11 @@ pub const GamepadState = struct {
     right_y: f32 = 0,
 
     fn rumbleGamepad(self: GamepadState, left: f32, right: f32, duration_ms: u32) void {
-        const left_i: u16 = @intFromFloat(std.math.lerp(0, 0xFFFF, left));
-        const right_i: u16 = @intFromFloat(std.math.lerp(0, 0xFFFF, right));
+        if (game.settings.rumble == 0)
+            return;
+        const multiplier: f32 = @as(f32, @floatFromInt(game.settings.rumble)) / 16.0;
+        const left_i: u16 = @intFromFloat(std.math.lerp(0, 0xFFFF, left * multiplier));
+        const right_i: u16 = @intFromFloat(std.math.lerp(0, 0xFFFF, right * multiplier));
         if(self.has_rumble) {
             if(!SDL.rumbleGamepad(self.handle, left_i, right_i, duration_ms))
             {
@@ -138,8 +151,11 @@ pub const GamepadState = struct {
     }
 
     fn rumbleTriggers(self: GamepadState, left: f32, right: f32, duration_ms: u32) void {
-        const left_i: u16 = @intFromFloat(std.math.lerp(0, 0xFFFF, left));
-        const right_i: u16 = @intFromFloat(std.math.lerp(0, 0xFFFF, right));
+        if (game.settings.rumble == 0)
+            return;
+        const multiplier: f32 = @as(f32, @floatFromInt(game.settings.rumble)) / 16.0;
+        const left_i: u16 = @intFromFloat(std.math.lerp(0, 0xFFFF, left * multiplier));
+        const right_i: u16 = @intFromFloat(std.math.lerp(0, 0xFFFF, right * multiplier));
         if(self.has_trigger_rumble) {
             if(!SDL.rumbleGamepadTriggers(self.handle, left_i, right_i, duration_ms))
             {
@@ -155,38 +171,40 @@ pub const GamepadState = struct {
     }
 
     pub fn triggerRumble(self: GamepadState, event: GameEvent) void {
-
-
         switch (event) {
-            .Event_HitEnemy =>
+            .None => {},
+            .HitEnemy =>
             {
                 self.rumbleGamepad(0.25, 0.25, 150);
             },
-            .Event_HitPlayer =>
+            .HitPlayer =>
             {
                 self.rumbleGamepad(1.0, 1.0, 75);
             },
-            .Event_PlayerHeadImpact =>
+            .PlayerHeadImpact =>
             {
                 self.rumbleGamepad(0.33, 0.33, 800);
             },
-            .Event_PlayerPickup,
-            .Event_PlayerPickupEnemy,
-            .Event_PlayerThrow => {
+            .PlayerPickup,
+            .PlayerPickupEnemy,
+            .PlayerThrow => {
                 self.rumbleTriggers(0.25, 0.25, 100);
             },
-            .Event_PlayerCollectWaypoint,
-            .Event_PlayerCollectBonus,
-            .Event_PlayerCollectLamp =>
+            .PlayerCollectWaypoint,
+            .PlayerCollectBonus,
+            .PlayerCollectLamp =>
             {
                 self.rumbleGamepad(0.1, 0.1, 100);
             },
-            .Event_PlayerJump => {
+            .PlayerJump => {
                 //self.rumbleGamepad(6000, 6000, 100);
             },
-            .Event_BallBounce => {
+            .BallBounce => {
                 self.rumbleGamepad(0.25, 0.25, 150);
             },
+            .Options_TestRumble => {
+                self.rumbleGamepad(1.0, 1.0, 100);
+            },
         }
     }
 };
diff --git a/src/objects.c b/src/objects.c
@@ -424,7 +424,7 @@ void shock(TITUS_level *level,
   }
 
   // Hit!
-  playEvent_c(Event_PlayerHeadImpact);
+  playc(PlayerHeadImpact);
   CHOC_FLAG = 24;
   if (object->sprite.killing) {
     if (!GODMODE) {
diff --git a/src/objects.zig b/src/objects.zig
@@ -322,7 +322,7 @@ fn shock(level: *lvl.Level, object: *lvl.Object) void {
     } else {
         if (((@as(c_int, @bitCast(@as(c_int, object.sprite.y))) - @as(c_int, @bitCast(@as(c_uint, object.sprite.spritedata.?.collheight)))) + @as(c_int, 1)) >= @as(c_int, @bitCast(@as(c_int, player.sprite.y)))) return;
     }
-    events.triggerEvent(.Event_PlayerHeadImpact);
+    events.triggerEvent(.PlayerHeadImpact);
     globals.CHOC_FLAG = 24;
     if (object.*.sprite.killing) {
         if (!globals.GODMODE) {
diff --git a/src/player.zig b/src/player.zig
@@ -896,7 +896,7 @@ fn collect_bonus(level: *lvl.Level, tileY: i16, tileX: i16) bool {
 
         if (bonus.bonustile >= (255 - 2)) {
             level.bonuscollected += 1;
-            events.triggerEvent(.Event_PlayerCollectBonus);
+            events.triggerEvent(.PlayerCollectBonus);
             INC_ENERGY(level);
         }
         level.setTile(@intCast(tileX), @intCast(tileY), bonus.replacetile);
@@ -915,15 +915,15 @@ fn collect_level_unlock(level: *lvl.Level, level_index: u8, tileY: i16, tileX: i
     game_state.unlock_level(allocator, level_index, level.lives) catch |err| {
         std.log.err("Failed to save progression: {s}", .{ @errorName(err) });
     };
-    events.triggerEvent(.Event_PlayerCollectLamp);
+    events.triggerEvent(.PlayerCollectLamp);
 }
 
 fn collect_checkpoint(level: *lvl.Level, tileY: i16, tileX: i16) void {
     if (!collect_bonus(level, tileY, tileX))
         return;
 
     const player = &level.player;
-    events.triggerEvent(.Event_PlayerCollectWaypoint);
+    events.triggerEvent(.PlayerCollectWaypoint);
     player.initX = player.sprite.x;
     player.initY = player.sprite.y;
     // carrying cage?
@@ -988,7 +988,7 @@ fn ACTION_PRG(level: *lvl.Level, action: PlayerAction) void {
         .Jump, .Jump_Carry => {
             // Handle a jump
             if (globals.jump_acceleration_counter == 0) {
-                events.triggerEvent(.Event_PlayerJump);
+                events.triggerEvent(.PlayerJump);
             }
             if (globals.jump_acceleration_counter >= 3) {
                 globals.jump_timer = 6; // Stop jump animation and acceleration
@@ -1143,7 +1143,7 @@ fn ACTION_PRG(level: *lvl.Level, action: PlayerAction) void {
                             }
 
                             // Take the object
-                            events.triggerEvent(.Event_PlayerPickup);
+                            events.triggerEvent(.PlayerPickup);
                             globals.FUME_FLAG = 0;
                             object.sprite.speed_y = 0;
                             object.sprite.speed_x = 0;
@@ -1219,7 +1219,7 @@ fn ACTION_PRG(level: *lvl.Level, action: PlayerAction) void {
                                     }
                                 }
 
-                                events.triggerEvent(.Event_PlayerPickupEnemy);
+                                events.triggerEvent(.PlayerPickupEnemy);
                                 globals.FUME_FLAG = 0;
                                 enemy.sprite.speed_y = 0;
                                 enemy.sprite.speed_x = 0;
@@ -1279,19 +1279,19 @@ fn ACTION_PRG(level: *lvl.Level, action: PlayerAction) void {
                         if (player_drop_carried(level)) |object| {
                             object.*.sprite.speed_y = speed_y;
                             object.*.sprite.speed_x = speed_x - (speed_x >> 2);
-                            events.triggerEvent(.Event_PlayerThrow);
+                            events.triggerEvent(.PlayerThrow);
                         }
                     } else { // Ordinary throw
                         globals.DROP_FLAG = true;
                         player.sprite2.speed_x = speed_x;
                         player.sprite2.speed_y = speed_y;
-                        events.triggerEvent(.Event_PlayerThrow);
+                        events.triggerEvent(.PlayerThrow);
                     }
                 } else { // Ordinary throw
                     globals.DROP_FLAG = true;
                     player.sprite2.speed_x = speed_x;
                     player.sprite2.speed_y = speed_y;
-                    events.triggerEvent(.Event_PlayerThrow);
+                    events.triggerEvent(.PlayerThrow);
                 }
             }
             sprites.updatesprite(level, &player.sprite, 10, true); // The same as in free fall
@@ -1505,7 +1505,7 @@ fn player_collide_with_objects(level: *lvl.Level) void {
 
         // If the ball lies on the ground
         if (off_object.sprite.speed_y == 0) {
-            events.triggerEvent(.Event_BallBounce);
+            events.triggerEvent(.BallBounce);
             off_object.sprite.speed_y = 0 - player.sprite.speed_y;
             off_object.sprite.y -= off_object.sprite.speed_y >> 4;
             globals.GRAVITY_FLAG = 4;
diff --git a/src/settings.zig b/src/settings.zig
@@ -50,6 +50,7 @@ pub const Settings = extern struct {
     window_height: u16 = window.game_height * 3,
     audio_backend: BackendType = .Adlib,
     input_mode: InputMode = .Modern,
+    rumble: u8 = 8, // 0 = off, 16 = max
     seen_intro: bool = false,
 
     pub fn make_new(allocator: Allocator) !ManagedJSON(Settings) {
@@ -110,6 +111,9 @@ pub const Settings = extern struct {
         if (settings.volume_master > 128) {
             settings.volume_master = 128;
         }
+        if (settings.rumble > 16) {
+            settings.rumble = 16;
+        }
         if (settings.window_width < window.game_width) {
             settings.window_width = window.game_width;
         }
diff --git a/src/ui/options_menu.zig b/src/ui/options_menu.zig

Original file line number	Diff line number	Diff line change
`@@ -1255,7 +1255,7 @@ void SET_NMI(TITUS_level *level) {`
`1255`	`1255`	`}`
`1256`	`1256`	`}`
`1257`	`1257`	`// If final enemy, remove energy`
`1258`		`- playEvent_c(Event_HitEnemy);`
	`1258`	`+ playc(HitEnemy);`
`1259`	`1259`	`DROP_FLAG = 0;`
`1260`	`1260`	`if (level->enemy[i].boss) {`
`1261`	`1261`	`if (INVULNERABLE_FLAG != 0) {`
`@@ -1342,7 +1342,7 @@ void ACTIONC_NMI(TITUS_level level, TITUS_enemy enemy) {`
`1342`	`1342`	`}`
`1343`	`1343`
`1344`	`1344`	`void KICK_ASH(TITUS_level level, TITUS_sprite enemysprite, int16_t power) {`
`1345`		`- playEvent_c(Event_HitPlayer);`
	`1345`	`+ playc(HitPlayer);`
`1346`	`1346`	`TITUS_sprite *p_sprite = &(level->player.sprite);`
`1347`	`1347`	`DEC_ENERGY(level);`
`1348`	`1348`	`DEC_ENERGY(level);`
Original file line number	Diff line number	Diff line change
`@@ -1151,7 +1151,7 @@ pub fn SET_NMI(level: *lvl.Level) void {`
`1151`	`1151`	`level.object[@as(c_ushort, @intCast(k))].sprite.speed_x = @as(i16, @bitCast(@as(c_short, @truncate(0 - @as(c_int, @bitCast(@as(c_int, level.object[@as(c_ushort, @intCast(k))].sprite.speed_x)))))));`
`1152`	`1152`	`}`
`1153`	`1153`	`}`
`1154`		`- events.triggerEvent(.Event_HitEnemy);`
	`1154`	`+ events.triggerEvent(.HitEnemy);`
`1155`	`1155`	`globals.DROP_FLAG = false;`
`1156`	`1156`	`if (enemy.boss) {`
`1157`	`1157`	`if (@as(c_int, @bitCast(@as(c_uint, globals.INVULNERABLE_FLAG))) != 0) {`
`@@ -1223,7 +1223,7 @@ fn ACTIONC_NMI(level: lvl.Level, enemy: lvl.Enemy) void {`
`1223`	`1223`	`}`
`1224`	`1224`
`1225`	`1225`	`fn KICK_ASH(level: lvl.Level, enemysprite: lvl.Sprite, power: i16) void {`
`1226`		`- events.triggerEvent(.Event_HitPlayer);`
	`1226`	`+ events.triggerEvent(.HitPlayer);`
`1227`	`1227`	`const p_sprite = &level.player.sprite;`
`1228`	`1228`
`1229`	`1229`	`// about 2 seconds worth of invulnereability frames`
Original file line number	Diff line number	Diff line change
`@@ -424,7 +424,7 @@ void shock(TITUS_level *level,`
`424`	`424`	`}`
`425`	`425`
`426`	`426`	`// Hit!`
`427`		`- playEvent_c(Event_PlayerHeadImpact);`
	`427`	`+ playc(PlayerHeadImpact);`
`428`	`428`	`CHOC_FLAG = 24;`
`429`	`429`	`if (object->sprite.killing) {`
`430`	`430`	`if (!GODMODE) {`
Original file line number	Diff line number	Diff line change
`@@ -322,7 +322,7 @@ fn shock(level: lvl.Level, object: lvl.Object) void {`
`322`	`322`	`} else {`
`323`	`323`	`if (((@as(c_int, @bitCast(@as(c_int, object.sprite.y))) - @as(c_int, @bitCast(@as(c_uint, object.sprite.spritedata.?.collheight)))) + @as(c_int, 1)) >= @as(c_int, @bitCast(@as(c_int, player.sprite.y)))) return;`
`324`	`324`	`}`
`325`		`- events.triggerEvent(.Event_PlayerHeadImpact);`
	`325`	`+ events.triggerEvent(.PlayerHeadImpact);`
`326`	`326`	`globals.CHOC_FLAG = 24;`
`327`	`327`	`if (object.*.sprite.killing) {`
`328`	`328`	`if (!globals.GODMODE) {`