add heal and damage sfx

README.md

 
 Unfortunately you will have to edit the hard-coded paths in `.vscode/launch.json`, I haven't been able to use variables there for some reason.
 
+For hard debugging cases the reverse stepping feature of the debugger in [GameRoy](https://github.com/Rodrigodd/gameroy) may come in handy.
+
 ## License
 
 The source code of this Duality GameBoy clone is licensed as GPLv3.

src/game.c

 
             if (health > damage) {
                 health -= damage;
+                if ((!sample_running()) && (sample_last() != SFX_DAMAGE)) {
+                    sample_play(SFX_DAMAGE);
+                }
             } else if (health <= damage) {
                 health = 0;
                 show_explosion(power);
                 break;
             }
-        } else if (damage < 0) {
+        } else if ((damage < 0) && (health < HEALTH_MAX)) {
+            if ((!sample_running()) && (sample_last() != SFX_HEAL)) {
+                sample_play(SFX_HEAL);
+            }
+
             health += -damage;
             if (health > HEALTH_MAX) {
                 health = HEALTH_MAX;
             }
+        } else if (damage == 0) {
+            sample_last_reset();
         }
 
         hide_sprites_range(hiwater, MAX_HARDWARE_SPRITES);

src/sample.c

 #include "sfx_shoot.h"
 #include "sfx_expl_orb.h"
 #include "sfx_expl_ship.h"
+#include "sfx_damage.h"
+#include "sfx_heal.h"
 #include "sample.h"
 
 BANKREF(sample)
 
+static enum SFXS play_sfx = SFX_COUNT;
 static uint8_t play_bank = 1;
 static const uint8_t *play_sample = 0;
 static uint16_t play_length = 0;
     { .bank = BANK(sfx_shoot),     .smp = sfx_shoot,     .len = sfx_shoot_SIZE >> 4 },     // SFX_SHOT
     { .bank = BANK(sfx_expl_orb),  .smp = sfx_expl_orb,  .len = sfx_expl_orb_SIZE >> 4 },  // SFX_EXPL_ORB
     { .bank = BANK(sfx_expl_ship), .smp = sfx_expl_ship, .len = sfx_expl_ship_SIZE >> 4 }, // SFX_EXPL_SHIP
+    { .bank = BANK(sfx_damage),    .smp = sfx_damage,    .len = sfx_damage_SIZE >> 4 },    // SFX_DAMAGE
+    { .bank = BANK(sfx_heal),      .smp = sfx_heal,      .len = sfx_heal_SIZE >> 4 },      // SFX_HEAL
 };
 
 void sample_play(enum SFXS sfx) BANKED {
     */
 
     CRITICAL {
+        play_sfx = sfx;
         play_bank = sfxs[sfx].bank;
         play_sample = sfxs[sfx].smp;
         play_length = sfxs[sfx].len;
     return (play_length > 0) ? 1 : 0;
 }
 
+enum SFXS sample_last(void) BANKED {
+    return play_sfx;
+}
+
+void sample_last_reset(void) BANKED {
+    play_sfx = SFX_COUNT;
+}
+
 #if 1
 
 // TODO C version has a slight 'beep' always? and much worse at lower volumes?

src/sample.h

     SFX_SHOT = 0,
     SFX_EXPL_ORB,
     SFX_EXPL_SHIP,
+    SFX_DAMAGE,
+    SFX_HEAL,
 
     SFX_COUNT
 };
 
 void sample_play(enum SFXS sfx) BANKED;
 uint8_t sample_running(void) BANKED;
+enum SFXS sample_last(void) BANKED;
+void sample_last_reset(void) BANKED;
 
 void sample_isr(void);
 

src/sound_game.c

  * See <http://www.gnu.org/licenses/>.
  */
 
+#include <assert.h>
+
 #include "banks.h"
 #include "sound_game.h"
 
     dEND
 };
 
+static_assert(sizeof(game_music) == sizeof(game_drums), "music loops need to be same length");
+
 const struct music music_game = {
     .notes = game_music,
     .notes2 = NULL,

src/sound_menu.c

  * See <http://www.gnu.org/licenses/>.
  */
 
+#include <assert.h>
+
 #include "banks.h"
 #include "sound_menu.h"
 
     dEND
 };
 
+static_assert(sizeof(menu_music)  == sizeof(menu_music2), "music loops need to be same length");
+static_assert(sizeof(menu_music2) == sizeof(menu_drums),  "music loops need to be same length");
+static_assert(sizeof(menu_music)  == sizeof(menu_drums),  "music loops need to be same length");
+
 const struct music music_menu = {
     .notes = menu_music,
     .notes2 = menu_music2,

src/sound_over.c

  * See <http://www.gnu.org/licenses/>.
  */
 
+#include <assert.h>
+
 #include "banks.h"
 #include "sound.h"
 #include "sound_over.h"
     dEND
 };
 
+static_assert(sizeof(over_notes)  == sizeof(over_notes2), "music loops need to be same length");
+static_assert(sizeof(over_notes2) == sizeof(over_drums),  "music loops need to be same length");
+static_assert(sizeof(over_notes)  == sizeof(over_drums),  "music loops need to be same length");
+
 const struct music music_over = {
     .notes = over_notes,
     .notes2 = over_notes2,

src/sprites.c

     }
 
     START_ROM_BANK(metasprites[sprite].bank) {
+        if (frame >= metasprites[sprite].ms_n) {
+            frame = 0;
+        }
 
-    if (frame >= metasprites[sprite].ms_n) {
-        frame = 0;
-    }
+        uint8_t pa_off = 0;
 
-    uint8_t pa_off = 0;
+        if (_cpu == CGB_TYPE) {
+            if ((metasprites[sprite].pa_i & PALETTE_ALL_FLAGS) == PALETTE_DYNAMIC_LOAD) {
+                uint8_t pa_i = frame;
+                if (pa_i >= metasprites[sprite].pa_n) {
+                    pa_i = 0;
+                }
 
-    if (_cpu == CGB_TYPE) {
-        if ((metasprites[sprite].pa_i & PALETTE_ALL_FLAGS) == PALETTE_DYNAMIC_LOAD) {
-            uint8_t pa_i = frame;
-            if (pa_i >= metasprites[sprite].pa_n) {
-                pa_i = 0;
-            }
+                set_sprite_palette((metasprites[sprite].pa_i & PALETTE_NO_FLAGS) + pa_i, 1, metasprites[sprite].pa + (pa_i * 4));
+            } else if ((metasprites[sprite].pa_i & PALETTE_ALL_FLAGS) == PALETTE_DYNAMIC_LOAD_IP) {
+                pa_off = frame;
+                if (pa_off >= metasprites[sprite].pa_n) {
+                    pa_off = 0;
+                }
 
-            set_sprite_palette((metasprites[sprite].pa_i & PALETTE_NO_FLAGS) + pa_i, 1, metasprites[sprite].pa + (pa_i * 4));
-        } else if ((metasprites[sprite].pa_i & PALETTE_ALL_FLAGS) == PALETTE_DYNAMIC_LOAD_IP) {
-            pa_off = frame;
-            if (pa_off >= metasprites[sprite].pa_n) {
-                pa_off = 0;
+                set_sprite_palette((metasprites[sprite].pa_i & PALETTE_NO_FLAGS), 1, metasprites[sprite].pa + (pa_off * 4));
             }
-
-            set_sprite_palette((metasprites[sprite].pa_i & PALETTE_NO_FLAGS), 1, metasprites[sprite].pa + (pa_off * 4));
         }
-    }
-
-    switch (flip) {
-        case FLIP_Y:
-            *hiwater += move_metasprite_flipy(
-                    metasprites[sprite].ms[frame], metasprites[sprite].off,
-                    (metasprites[sprite].pa_i - pa_off) & PALETTE_NO_FLAGS, *hiwater,
-                    DEVICE_SPRITE_PX_OFFSET_X + (DEVICE_SCREEN_PX_WIDTH / 2) + x_off,
-                    DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
-            break;
-
-        case FLIP_XY:
-            *hiwater += move_metasprite_flipxy(
-                    metasprites[sprite].ms[frame], metasprites[sprite].off,
-                    (metasprites[sprite].pa_i - pa_off) & PALETTE_NO_FLAGS, *hiwater,
-                    DEVICE_SPRITE_PX_OFFSET_X + (DEVICE_SCREEN_PX_WIDTH / 2) + x_off,
-                    DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
-            break;
-
-        case FLIP_X:
-            *hiwater += move_metasprite_flipx(
-                    metasprites[sprite].ms[frame], metasprites[sprite].off,
-                    (metasprites[sprite].pa_i - pa_off) & PALETTE_NO_FLAGS, *hiwater,
-                    DEVICE_SPRITE_PX_OFFSET_X + (DEVICE_SCREEN_PX_WIDTH / 2) + x_off,
-                    DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
-            break;
-
-        case FLIP_NONE:
-        default:
-            *hiwater += move_metasprite_ex(
-                    metasprites[sprite].ms[frame], metasprites[sprite].off,
-                    (metasprites[sprite].pa_i - pa_off) & PALETTE_NO_FLAGS, *hiwater,
-                    DEVICE_SPRITE_PX_OFFSET_X + (DEVICE_SCREEN_PX_WIDTH / 2) + x_off,
-                    DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
-            break;
-    }
 
+        switch (flip) {
+            case FLIP_Y:
+                *hiwater += move_metasprite_flipy(
+                        metasprites[sprite].ms[frame], metasprites[sprite].off,
+                        (metasprites[sprite].pa_i - pa_off) & PALETTE_NO_FLAGS, *hiwater,
+                        DEVICE_SPRITE_PX_OFFSET_X + (DEVICE_SCREEN_PX_WIDTH / 2) + x_off,
+                        DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
+                break;
+
+            case FLIP_XY:
+                *hiwater += move_metasprite_flipxy(
+                        metasprites[sprite].ms[frame], metasprites[sprite].off,
+                        (metasprites[sprite].pa_i - pa_off) & PALETTE_NO_FLAGS, *hiwater,
+                        DEVICE_SPRITE_PX_OFFSET_X + (DEVICE_SCREEN_PX_WIDTH / 2) + x_off,
+                        DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
+                break;
+
+            case FLIP_X:
+                *hiwater += move_metasprite_flipx(
+                        metasprites[sprite].ms[frame], metasprites[sprite].off,
+                        (metasprites[sprite].pa_i - pa_off) & PALETTE_NO_FLAGS, *hiwater,
+                        DEVICE_SPRITE_PX_OFFSET_X + (DEVICE_SCREEN_PX_WIDTH / 2) + x_off,
+                        DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
+                break;
+
+            case FLIP_NONE:
+            default:
+                *hiwater += move_metasprite_ex(
+                        metasprites[sprite].ms[frame], metasprites[sprite].off,
+                        (metasprites[sprite].pa_i - pa_off) & PALETTE_NO_FLAGS, *hiwater,
+                        DEVICE_SPRITE_PX_OFFSET_X + (DEVICE_SCREEN_PX_WIDTH / 2) + x_off,
+                        DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
+                break;
+        }
     } END_ROM_BANK
 }