Loadless timer, death counter, R menuing

src/mods/ballcolor.cpp

@@ -2,6 +2,7 @@
 
 #include "mkb/mkb.h"
 
+#include "mkb/mkb2_ghidra.h"
 #include "systems/heap.h"
 #include "systems/pad.h"
 #include "systems/pref.h"
@@ -56,29 +57,37 @@ static u8 convert_to_ape_color_id(u8 color_choice) {
     return color_choice - 1;
 }
 
+// Set both active_monkey_id and selected_characters so savestates work when we use gotostory even
+// if we haven't manually selected a monkey on the character select screen
 void switch_monkey() {
     switch (MonkeyType(pref::get(pref::Pref::MonkeyType))) {
         case MonkeyType::Default: {
             break;
         }
         case MonkeyType::Aiai: {
             mkb::active_monkey_id[mkb::curr_player_idx] = 0;
+            mkb::selected_characters[mkb::curr_player_idx] = 0;
             break;
         }
         case MonkeyType::Meemee: {
             mkb::active_monkey_id[mkb::curr_player_idx] = 1;
+            mkb::selected_characters[mkb::curr_player_idx] = 1;
             break;
         }
         case MonkeyType::Baby: {
             mkb::active_monkey_id[mkb::curr_player_idx] = 2;
+            mkb::selected_characters[mkb::curr_player_idx] = 2;
             break;
         }
         case MonkeyType::Gongon: {
             mkb::active_monkey_id[mkb::curr_player_idx] = 3;
+            mkb::selected_characters[mkb::curr_player_idx] = 3;
             break;
         }
         case MonkeyType::Random: {
-            mkb::active_monkey_id[mkb::curr_player_idx] = mkb::rand() % 4;
+            u8 monkey_id = mkb::rand() % 4;
+            mkb::active_monkey_id[mkb::curr_player_idx] = monkey_id;
+            mkb::selected_characters[mkb::curr_player_idx] = monkey_id;
             break;
         }
     }
@@ -150,8 +159,7 @@ void tick() {
                 u32 blue = CLAMP(((mkb::rand() % 256) + bonus_brightness), 0, 0xff);
                 s_current_color = {static_cast<u8>(red), static_cast<u8>(green),
                                    static_cast<u8>(blue), 0};
-                *reinterpret_cast<GXColor *>(relutil::relocate_addr(0x80472a34)) =
-                    s_current_color;
+                *reinterpret_cast<GXColor *>(relutil::relocate_addr(0x80472a34)) = s_current_color;
             }
             break;
         }

src/mods/cmseg.cpp

@@ -5,6 +5,7 @@
 #include "mods/freecam.h"
 #include "systems/log.h"
 #include "systems/pref.h"
+#include "systems/textinfo.h"
 #include "utils/draw.h"
 #include "utils/macro_utils.h"
 #include "utils/patch.h"
@@ -35,6 +36,9 @@ static s8 s_overwritten_starting_monkeys;
 
 static u32 s_pbs[14];
 
+using Slot = textinfo::Slot;
+using Format = timerdisp::TimeFormat;
+
 // static void debug_print_course(mkb::CourseCommand *course, u32 entry_count)
 //{
 //     static const char *type_strs[] = {"COURSE_CMD_IF", "COURSE_CMD_THEN", "COURSE_CMD_INFO",
@@ -415,7 +419,7 @@ void tick() {
 }
 
 void disp() {
-    if (!pref::get(pref::Pref::CmTimer) || freecam::should_hide_hud()) return;
+    if (!pref::get(pref::Pref::CmTimer)) return;
 
     if (s_state == State::SegActive || s_state == State::SegComplete) {
         u32 seg = static_cast<u32>(s_seg_request);
@@ -424,7 +428,8 @@ void disp() {
             color = draw::GOLD;
         else
             color = draw::WHITE;
-        timerdisp::draw_timer(static_cast<s32>(s_seg_time), "SEG:", 0, color, false);
+        textinfo::draw_timer(Slot::Right, color, "SEG:", static_cast<s32>(s_seg_time),
+                             Format::AlwaysLeadNonHours);
     }
 }
 

src/mods/deathcounter.cpp

@@ -0,0 +1,159 @@
+#include "deathcounter.h"
+
+#include "mkb/mkb.h"
+
+#include "storyreset.h"
+#include "systems/goal.h"
+#include "systems/pref.h"
+#include "systems/savest.h"
+#include "systems/textinfo.h"
+#include "utils/draw.h"
+#include "utils/macro_utils.h"
+#include "utils/mode.h"
+
+namespace deathcounter {
+
+constexpr u16 WORLD_COUNT = mode::WORLD_COUNT;
+
+static u32 s_world_death_count[WORLD_COUNT] = {};
+static savest::Action s_previous_frame_action = savest::Action::None;
+// Flag to determine when we should/shouldn't increment the death counter
+static bool s_can_incr_death_counter = false;
+
+using Slot = textinfo::Slot;
+using Format = timerdisp::TimeFormat;
+
+u32 get_total_death_count() {
+    u32 total = 0;
+    for (u16 k = 0; k < WORLD_COUNT; k++) {
+        total += s_world_death_count[k];
+    }
+    return total;
+}
+
+u32 get_world_death_count(u16 world_idx) {
+    u16 clamped_idx = MIN(world_idx, WORLD_COUNT - 1);  // clamp for safety
+    return s_world_death_count[clamped_idx];
+}
+
+void increment_world_death_counter() {
+    // Check the pref for count first stage deaths and if we're on the first stage
+    if (!pref::get(pref::Pref::CountFirstStageDeaths) &&
+        mode::get_storymode_total_clear_count() == 0) {
+        return;
+    }
+    s_world_death_count[mkb::scen_info.world] += 1;  // death counter for the current world
+    s_can_incr_death_counter = false;                // so we only increment once per death
+}
+
+void reset_flag() {
+    s_can_incr_death_counter = false;
+}
+
+void reset_death_counters() {
+    for (u16 k = 0; k < WORLD_COUNT; k++) {
+        s_world_death_count[k] = 0;
+    }
+    reset_flag();
+}
+
+bool loaded_state() {
+    return savest::get_last_action() == savest::Action::Load &&
+           s_previous_frame_action == savest::Action::None;
+}
+
+// When we're done holding the savestate button/when gameplay resumes
+void update_flag_on_state_release() {
+    if (goal::is_gameplay_exact() && savest::get_last_action() == savest::Action::None) {
+        // As soon as we're done holding the load state button (or just any time we're controlling
+        // the monkey on the stage), we're allowed to die
+        s_can_incr_death_counter = true;
+    }
+}
+
+bool should_count_as_normal_death() {
+    bool retried_without_clearing =
+        mode::is_spin_in_init(mkb::sub_mode) && s_can_incr_death_counter;
+    bool left_stage_without_clearing =
+        mode::is_stage_exit_submode(mkb::sub_mode) && s_can_incr_death_counter;
+    // Need to also check the flag for death init submodes in case we fall out and let the animation
+    // play out (ie we enter 2 "death init" submodes before resuming gameplay)
+    bool died = mode::is_death_init(mkb::sub_mode) && s_can_incr_death_counter;
+    return retried_without_clearing || left_stage_without_clearing || died;
+}
+
+bool should_count_as_savestate_death() {
+    return loaded_state() && s_can_incr_death_counter;
+}
+
+void count_deaths() {
+    if (goal::is_postgoal_exact()) {
+        s_can_incr_death_counter = false;
+    }
+
+    if (should_count_as_normal_death() || should_count_as_savestate_death()) {
+        increment_world_death_counter();
+    }
+}
+
+void tick() {
+    if (storyreset::should_reset_run()) {
+        reset_death_counters();
+    }
+
+    // Whenever entering a new stage, reset our flag
+    if (mode::is_spin_in_first_init(mkb::sub_mode)) {
+        reset_flag();
+    }
+
+    update_flag_on_state_release();
+    count_deaths();
+
+    // Only after we're done doing death checks for this frame do we update s_previous_frame_action
+    s_previous_frame_action = savest::get_last_action();
+}
+
+bool should_display_death_counter() {
+    u8 pref = pref::get(pref::Pref::DeathCounterDisplayOptions);
+
+    using DeathCounterOptions = storyreset::StoryDisplayOptions;
+
+    switch (DeathCounterOptions(pref)) {
+        case DeathCounterOptions::AlwaysShow:
+            return true;
+        case DeathCounterOptions::BetweenWorlds:
+            return goal::is_between_worlds();
+        case DeathCounterOptions::EndOfRun:
+            return goal::is_run_complete();
+        case DeathCounterOptions::DontShow:
+            return false;
+        default:
+            // Unreachable
+            return false;
+    }
+}
+
+bool should_not_display_counter_at_all() {
+    if (!mode::is_main_game_mode_story(mkb::main_game_mode)) {
+        // If we're in the menus outside of a story mode run due to an accidental exit game, we
+        // still want to be able to display the counter if we haven't reset it yet
+        return !storyreset::is_run_active();
+    } else {
+        return false;
+    }
+}
+
+void disp() {
+    if (should_not_display_counter_at_all()) {
+        return;
+    }
+
+    if (should_display_death_counter()) {
+        // Technically not a timer, but we can still use this function without specifying any
+        // special formatting
+        textinfo::draw_timer(Slot::Left, draw::WHITE, "Deaths:", get_total_death_count(),
+                             Format::Unformatted);
+    }
+}
+
+}  // namespace deathcounter

src/mods/deathcounter.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "mkb/mkb.h"
+
+namespace deathcounter {
+
+u32 get_total_death_count();
+u32 get_world_death_count(u16 world_idx);
+bool should_display_death_counter();
+
+void tick();
+void disp();
+
+}  // namespace deathcounter

src/mods/freecam.cpp

@@ -5,6 +5,7 @@
 #include "systems/binds.h"
 #include "systems/pad.h"
 #include "systems/pref.h"
+#include "systems/textinfo.h"
 #include "utils/draw.h"
 #include "utils/macro_utils.h"
 #include "utils/patch.h"
@@ -169,6 +170,13 @@ void tick() {
             pref::save();
         }
     }
+
+    // Handle hiding all ui elements coming from textinfo
+    if (should_hide_hud()) {
+        textinfo::set_drawing_state(false);
+    } else {
+        textinfo::set_drawing_state(true);
+    }
 }
 
 }  // namespace freecam

src/mods/gotostory.cpp

@@ -4,14 +4,12 @@
 
 namespace gotostory {
 
-enum class State {
-    Default,
-    LoadMenuReq,
-    LoadStoryReq,
-};
-
 static State s_state = State::Default;
 
+State get_gotostory_state() {
+    return s_state;
+}
+
 void load_storymode() {
     if (mkb::main_mode == mkb::MD_SEL) {
         s_state = State::LoadStoryReq;

src/mods/gotostory.h

@@ -2,7 +2,14 @@
 
 namespace gotostory {
 
+enum class State {
+    Default,
+    LoadMenuReq,
+    LoadStoryReq,
+};
+
 void tick();
 void load_storymode();
+State get_gotostory_state();
 
 }  // namespace gotostory