fix sum shit

Author: timkicker

src/app/App.cpp

@@ -79,11 +79,27 @@ bool App::init() {
     elog("Network: socket_lib_init done, network ready");
 #endif
 
-    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) != 0) {
+    // Do NOT add SDL_INIT_GAMECONTROLLER. SDL2-wuhb crashes the RPX loader
+    // before main() runs ("failed to load payload"). We only need
+    // SDL_JOYBUTTONDOWN events anyway, not the SDL_GameController API.
+    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) != 0) {
         LOG_ERROR("SDL_Init failed: %s", SDL_GetError());
         return false;
     }
     elog("SDL_Init OK");
+    // Open every already-connected joystick so SDL starts forwarding events
+    // for it. SDL only emits SDL_JOYBUTTONDOWN from opened joysticks. New
+    // devices that plug in later are handled in App::run via
+    // SDL_JOYDEVICEADDED.
+    {
+        int n = SDL_NumJoysticks();
+        elogf("SDL: %d joystick(s) connected at startup", n);
+        for (int i = 0; i < n; i++) {
+            SDL_Joystick* j = SDL_JoystickOpen(i);
+            if (j) elogf("  opened: %s", SDL_JoystickName(j));
+            else   elogf("  open failed for joystick %d: %s", i, SDL_GetError());
+        }
+    }
     if (TTF_Init() != 0) {
         LOG_ERROR("TTF_Init failed: %s", TTF_GetError());
         return false;
@@ -204,9 +220,33 @@ void App::run() {
         if (frameNum < 10) elogf("frame %d begin", frameNum);
         SDL_Event event;
         while (SDL_PollEvent(&event)) {
-            if (event.type == SDL_QUIT) {
-                elog("got SDL_QUIT");
-                m_running = false;
+            switch (event.type) {
+                case SDL_QUIT:
+                    elog("got SDL_QUIT");
+                    m_running = false;
+                    break;
+                case SDL_JOYDEVICEADDED: {
+                    // SDL won't deliver button events from a joystick until
+                    // someone opens it. Pattern from fortheusers/chesto.
+                    SDL_Joystick* j = SDL_JoystickOpen(event.jdevice.which);
+                    if (j) elogf("joystick connected: %s", SDL_JoystickName(j));
+                    break;
+                }
+                case SDL_JOYDEVICEREMOVED: {
+                    SDL_Joystick* j = SDL_JoystickFromInstanceID(event.jdevice.which);
+                    if (j) {
+                        elogf("joystick disconnected: %s", SDL_JoystickName(j));
+                        SDL_JoystickClose(j);
+                    }
+                    break;
+                }
+                case SDL_JOYBUTTONDOWN:
+                    // Single code path for all Wii U controllers: GamePad,
+                    // Pro Controller, Wii Remote (+ extensions), Classic.
+                    // SDL2-wuhb's joystick driver normalises every device to
+                    // the same button-index space (see Input.h enum).
+                    Input::onJoyButtonDown(event.jbutton.button);
+                    break;
             }
         }
         update();

src/app/Input.cpp

@@ -0,0 +1,37 @@
+#include "Input.h"
+
+uint32_t Input::s_pressedBits = 0;
+
+void Input::onJoyButtonDown(int buttonIdx) {
+    if (buttonIdx < 0 || buttonIdx >= BTN_COUNT) return;
+    s_pressedBits |= (1u << buttonIdx);
+}
+
+Input Input::read() {
+    Input in;
+    const uint32_t bits = s_pressedBits;
+    s_pressedBits = 0;
+
+    auto has = [bits](BtnIdx b) { return (bits & (1u << b)) != 0; };
+
+    in.a     = has(BTN_A);
+    in.b     = has(BTN_B);
+    in.x     = has(BTN_X);
+    in.y     = has(BTN_Y);
+    in.l     = has(BTN_L);
+    in.r     = has(BTN_R);
+    in.zl    = has(BTN_ZL);
+    in.zr    = has(BTN_ZR);
+    in.plus  = has(BTN_PLUS);
+    in.minus = has(BTN_MINUS);
+    // D-pad OR'd with left-stick-emulation so sticks navigate the UI just
+    // like the D-pad. Right stick is intentionally ignored: nothing in the
+    // app uses it, and an over-eager grip would otherwise trigger nav events.
+    in.up    = has(BTN_UP)    || has(BTN_LSTICK_UP);
+    in.down  = has(BTN_DOWN)  || has(BTN_LSTICK_DOWN);
+    in.left  = has(BTN_LEFT)  || has(BTN_LSTICK_LEFT);
+    in.right = has(BTN_RIGHT) || has(BTN_LSTICK_RIGHT);
+    // home stays false; Aroma intercepts HOME before SDL sees it.
+
+    return in;
+}

src/app/Input.h

@@ -1,6 +1,30 @@
 #pragma once
-#include <vpad/input.h>
+#include <cstdint>
 
+// Game input, populated from SDL joystick events. The same code path works
+// for every Wii U input device (GamePad, Pro Controller, Wii Remote +/-
+// extensions, Classic Controller) because SDL2-wuhb's WIIU_JoystickInit
+// already initialises VPAD + KPAD + URCC and emits a single SDL_JOYBUTTONDOWN
+// per physical button press, with a canonical button index that matches
+// across all device types. See devkitPro/SDL src/joystick/wiiu for the
+// per-device index maps:
+//
+//   0=A           1=B           2=X            3=Y
+//   4=STICK_L_PUSH  5=STICK_R_PUSH
+//   6=L           7=R           8=ZL           9=ZR
+//   10=PLUS       11=MINUS
+//   12=LEFT       13=UP         14=RIGHT       15=DOWN
+//   16=LSTICK_LEFT  17=LSTICK_UP  18=LSTICK_RIGHT  19=LSTICK_DOWN
+//   20=RSTICK_LEFT  21=RSTICK_UP  22=RSTICK_RIGHT  23=RSTICK_DOWN
+//
+// SDL handles the stick-as-d-pad emulation for us: when the stick crosses
+// the threshold, SDL fires a SDL_JOYBUTTONDOWN with the corresponding
+// LSTICK_* index, then SDL_JOYBUTTONUP when it returns to centre. Same
+// edge-triggered semantics as the actual D-pad. We don't need to poll axes.
+//
+// App::run's event loop calls Input::onJoyButtonDown() for each
+// SDL_JOYBUTTONDOWN. Per frame, App::update() calls Input::read() which
+// returns a freshly drained snapshot.
 struct Input {
     bool up    = false;
     bool down  = false;
@@ -16,32 +40,33 @@ struct Input {
     bool zr    = false;
     bool plus  = false;
     bool minus = false;
-    bool home  = false;
+    bool home  = false; // never fires: Aroma intercepts HOME before us
 
-    static Input read() {
-        Input in;
-        VPADStatus status;
-        VPADReadError err;
-        if (VPADRead(VPAD_CHAN_0, &status, 1, &err) > 0) {
-            uint32_t btn = status.trigger;
-            float lx = status.leftStick.x;
-            float ly = status.leftStick.y;
-            in.up    = (btn & VPAD_BUTTON_UP)    || ly >  0.5f;
-            in.down  = (btn & VPAD_BUTTON_DOWN)  || ly < -0.5f;
-            in.left  = (btn & VPAD_BUTTON_LEFT)  || lx < -0.5f;
-            in.right = (btn & VPAD_BUTTON_RIGHT) || lx >  0.5f;
-            in.a     = btn & VPAD_BUTTON_A;
-            in.b     = btn & VPAD_BUTTON_B;
-            in.l     = btn & VPAD_BUTTON_L;
-            in.r     = btn & VPAD_BUTTON_R;
-            in.y     = btn & VPAD_BUTTON_Y;
-            in.x     = btn & VPAD_BUTTON_X;
-            in.zl    = btn & VPAD_BUTTON_ZL;
-            in.zr    = btn & VPAD_BUTTON_ZR;
-            in.plus  = btn & VPAD_BUTTON_PLUS;
-            in.minus = btn & VPAD_BUTTON_MINUS;
-            in.home  = btn & VPAD_BUTTON_HOME;
-        }
-        return in;
-    }
+    // SDL2-wuhb button indices. Order MUST match the arrays in the SDL
+    // joystick driver (devkitPro/SDL src/joystick/wiiu/SDL_wiiujoystick.h).
+    enum BtnIdx {
+        BTN_A = 0, BTN_B, BTN_X, BTN_Y,
+        BTN_STICK_L_PUSH, BTN_STICK_R_PUSH,
+        BTN_L, BTN_R, BTN_ZL, BTN_ZR,
+        BTN_PLUS, BTN_MINUS,
+        BTN_LEFT, BTN_UP, BTN_RIGHT, BTN_DOWN,
+        BTN_LSTICK_LEFT, BTN_LSTICK_UP, BTN_LSTICK_RIGHT, BTN_LSTICK_DOWN,
+        BTN_RSTICK_LEFT, BTN_RSTICK_UP, BTN_RSTICK_RIGHT, BTN_RSTICK_DOWN,
+        BTN_COUNT
+    };
+
+    // Called from App::run's event loop when a SDL_JOYBUTTONDOWN arrives.
+    // Accumulates presses across the frame; read() drains.
+    static void onJoyButtonDown(int buttonIdx);
+
+    // Drain the accumulator into a fresh Input. Called once per frame in
+    // App::update(), BEFORE the active screen's handleInput. Resets the
+    // accumulator so the same press isn't seen twice.
+    static Input read();
+
+private:
+    // Bitfield of indices pressed since last read(). 24 bits used; uint32_t
+    // is comfortable. Not atomic: SDL_PollEvent runs on the main thread, as
+    // does read().
+    static uint32_t s_pressedBits;
 };

src/ui/BrowseScroll.h

@@ -0,0 +1,25 @@
+#pragma once
+
+// Pure scroll-window math for the Browse-tab card grid.
+//
+// Inputs:
+//   currentScroll  top row index currently visible
+//   selectedRow    row index of the cursor (0-based)
+//   visibleRows    how many rows fit on screen (must be >= 1)
+// Returns: the new scroll value that keeps `selectedRow` in view with
+// minimal movement (no scroll if already visible).
+//
+// Extracted for unit testing; the actual MainLayout::handleBrowseInput
+// just calls this and assigns the result.
+inline int computeBrowseScroll(int currentScroll, int selectedRow, int visibleRows) {
+    if (visibleRows < 1) visibleRows = 1;
+    if (currentScroll < 0) currentScroll = 0;
+    if (selectedRow < currentScroll) {
+        return selectedRow;
+    }
+    int lastVisible = currentScroll + visibleRows - 1;
+    if (selectedRow > lastVisible) {
+        return selectedRow - visibleRows + 1;
+    }
+    return currentScroll;
+}

src/ui/MainLayout.cpp

@@ -3,6 +3,7 @@
 #include "ui/DetailScreen.h"
 #include "ui/DownloadQueueScreen.h"
 #include "ui/TagFilterScreen.h"
+#include "ui/BrowseScroll.h"
 #include "net/DownloadQueue.h"
 #include <sysapp/launch.h>
 #include "mods/InstalledScanner.h"
@@ -211,6 +212,7 @@ void MainLayout::handleBrowseInput(const Input& input) {
     auto& mods     = games[m_selectedGame].mods;
     int   modCount = (int)mods.size();
     int   cols     = CARDS_PER_ROW;
+    int   prevGame = m_selectedGame;
 
     if (input.right) {
         if ((m_selectedMod % cols) < cols - 1 && m_selectedMod + 1 < modCount) {
@@ -229,6 +231,18 @@ void MainLayout::handleBrowseInput(const Input& input) {
     if (input.down) { int n = m_selectedMod + cols; if (n < modCount) { m_selectedMod = n; AudioManager::get().playSound(SoundId::Navigate); } }
     if (input.up)   { int p = m_selectedMod - cols; if (p >= 0)       { m_selectedMod = p; AudioManager::get().playSound(SoundId::Navigate); } }
 
+    // Reset scroll when the selected game changes, then ensure the new cursor
+    // is visible. Otherwise just adjust scroll if cursor moved off the visible
+    // rows. visibleRows is derived from the actual window height minus the
+    // grid top (header/tab strip) and a small bottom strip for the hint line.
+    if (m_selectedGame != prevGame) m_browseScrollRow = 0;
+    const int H = m_app->screenHeight();
+    const int bottomHint = 30;
+    int visibleRows = (H - GRID_TOP - bottomHint) / (CARD_H + CARD_PAD);
+    if (visibleRows < 1) visibleRows = 1;
+    int selRow = m_selectedMod / cols;
+    m_browseScrollRow = computeBrowseScroll(m_browseScrollRow, selRow, visibleRows);
+
     // Pre-warm ImageCache for the currently-selected mod's images. When the
     // user presses A, DetailScreen finds them already cached -> no freeze.
     if (m_selectedMod < modCount) {
@@ -261,6 +275,7 @@ void MainLayout::handleBrowseInput(const Input& input) {
             [this](std::set<std::string> picked) {
                 m_activeTags = std::move(picked);
                 m_selectedMod = 0; // reset cursor when filter changes
+                m_browseScrollRow = 0;
                 persistUiState();
             }));
     }
@@ -682,11 +697,19 @@ void MainLayout::renderBrowse(SDL_Renderer* renderer) {
         default: break;
     }
     auto& mods = sortedMods;
+    // Skip cards above the visible scroll window or below the bottom hint
+    // line. Without this, render walks through hundreds of cards offscreen
+    // for large repos, and the cursor visually disappears past the screen.
+    const int rowH = CARD_H + CARD_PAD;
+    const int bottomHint = 30;
     for (int i = 0; i < (int)mods.size(); i++) {
         auto& mod = mods[i];
         bool  sel = (i == m_selectedMod);
+        int   row = i / CARDS_PER_ROW;
+        if (row < m_browseScrollRow) continue;          // above viewport
         int   x   = cx + CARD_PAD + (i % CARDS_PER_ROW) * (CARD_W + CARD_PAD);
-        int   y   = GRID_TOP      + (i / CARDS_PER_ROW) * (CARD_H + CARD_PAD);
+        int   y   = GRID_TOP      + (row - m_browseScrollRow) * rowH;
+        if (y + CARD_H > H - bottomHint) break;          // below viewport (rows are in order)
 
         SDL_SetRenderDrawColor(renderer, 25, 25, 40, 255);
         SDL_Rect card = {x, y, CARD_W, CARD_H};

src/ui/MainLayout.h

@@ -76,6 +76,7 @@ class MainLayout : public Screen {
     Repo                    m_repo;
     int m_selectedGame = 0;
     int m_selectedMod  = 0;
+    int m_browseScrollRow = 0;  // top visible row in the Browse card grid
 
     enum class SortMode { Default, NameAZ, Version };
     SortMode m_sortMode = SortMode::Default;

tests/CMakeLists.txt

@@ -31,6 +31,8 @@ add_executable(cupstore_tests
     test_http_client.cpp
     test_text_cache.cpp
     test_sha256.cpp
+    test_browse_scroll.cpp
+    test_input.cpp
     curl_mock.cpp
     stubs.cpp
     ${SRC}/mods/ConflictChecker.cpp
@@ -46,6 +48,7 @@ add_executable(cupstore_tests
     ${SRC}/net/HttpClient.cpp
     ${SRC}/util/TextCache.cpp
     ${SRC}/util/sha256.cpp
+    ${SRC}/app/Input.cpp
 )
 # TextCache pulls SDL headers; we only test the no-renderer paths so functions
 # can be stubbed.

tests/test_browse_scroll.cpp

@@ -0,0 +1,58 @@
+#include <catch2/catch_test_macros.hpp>
+#include "ui/BrowseScroll.h"
+
+// computeBrowseScroll(currentScroll, selectedRow, visibleRows) -> newScroll
+//
+// Property: after calling this, selectedRow is in [newScroll, newScroll + visibleRows - 1],
+// and we move the window by the minimum amount necessary.
+
+TEST_CASE("BrowseScroll: cursor already visible -> no scroll change", "[browse-scroll]") {
+    REQUIRE(computeBrowseScroll(0, 0, 4) == 0);
+    REQUIRE(computeBrowseScroll(0, 3, 4) == 0);
+    REQUIRE(computeBrowseScroll(2, 2, 4) == 2);
+    REQUIRE(computeBrowseScroll(2, 5, 4) == 2);
+}
+
+TEST_CASE("BrowseScroll: cursor below viewport -> scroll down minimally", "[browse-scroll]") {
+    // visibleRows=4, scroll=0 means rows 0..3 visible. selectedRow=4 needs scroll=1.
+    REQUIRE(computeBrowseScroll(0, 4, 4) == 1);
+    // selectedRow=10 -> need rows 7..10 visible -> scroll=7
+    REQUIRE(computeBrowseScroll(0, 10, 4) == 7);
+}
+
+TEST_CASE("BrowseScroll: cursor above viewport -> scroll up to expose it", "[browse-scroll]") {
+    // scroll=5 visibleRows=4 means rows 5..8 visible. selectedRow=3 means jump up.
+    REQUIRE(computeBrowseScroll(5, 3, 4) == 3);
+    REQUIRE(computeBrowseScroll(10, 0, 4) == 0);
+}
+
+TEST_CASE("BrowseScroll: scrolling row-by-row matches expected window", "[browse-scroll]") {
+    int scroll = 0;
+    const int rows = 3;
+    // Simulate cursor moving down 0..10
+    for (int sel = 0; sel <= 10; sel++) {
+        scroll = computeBrowseScroll(scroll, sel, rows);
+        // sel must be visible
+        REQUIRE(sel >= scroll);
+        REQUIRE(sel <= scroll + rows - 1);
+    }
+    // After scrolling to row 10 with visibleRows=3, scroll should be 8
+    REQUIRE(scroll == 8);
+}
+
+TEST_CASE("BrowseScroll: degenerate visibleRows clamped to 1", "[browse-scroll]") {
+    REQUIRE(computeBrowseScroll(0, 5, 0) == 5);
+    REQUIRE(computeBrowseScroll(0, 5, -1) == 5);
+}
+
+TEST_CASE("BrowseScroll: negative currentScroll is normalised", "[browse-scroll]") {
+    // Shouldn't happen in practice, but ensure we don't underflow.
+    REQUIRE(computeBrowseScroll(-3, 2, 4) == 0);  // row 2 visible from scroll=0
+}
+
+TEST_CASE("BrowseScroll: selectedRow == lastVisible edge", "[browse-scroll]") {
+    // visibleRows=4 scroll=0 -> last visible = 3. row 3 should not move scroll.
+    REQUIRE(computeBrowseScroll(0, 3, 4) == 0);
+    // row 4 should bump scroll by 1.
+    REQUIRE(computeBrowseScroll(0, 4, 4) == 1);
+}