From e2631b51701d59fa1f35c6b308938443f09cc46f Mon Sep 17 00:00:00 2001 From: jakobkg Date: Thu, 1 Mar 2018 13:18:54 +0100 Subject: [PATCH 1/5] [WIP] Add support for additional controllers Initial commit, currently broken. Bloated lib_easy by ~1000 lines. No buttons work, the unmodified code for the sticks still does. --- src/draw.c | 32 +- src/lib_easy.c | 927 ++++++++++++++++++++++++++++++++++++++++++++++++- src/lib_easy.h | 36 +- src/main.c | 18 +- src/savemng.c | 4 +- 5 files changed, 981 insertions(+), 36 deletions(-) diff --git a/src/draw.c b/src/draw.c index a353517..6d68dfd 100644 --- a/src/draw.c +++ b/src/draw.c @@ -345,21 +345,21 @@ void draw_bitmap(FT_Bitmap* bitmap, FT_Int x, FT_Int y) { } } break; - case FT_PIXEL_MODE_BGRA: - x_max = x + bitmap->width/2; - for (i = x, p = 0; i < x_max; i++, p++) { - for (j = y, q = 0; j < y_max; j++, q++) { - if (i < 0 || j < 0 || i >= 854 || j >= 480) continue; - u8 cb = bitmap->buffer[q * bitmap->pitch + p * 4]; - u8 cg = bitmap->buffer[q * bitmap->pitch + p * 4 + 1]; - u8 cr = bitmap->buffer[q * bitmap->pitch + p * 4 + 2]; - u8 ca = bitmap->buffer[q * bitmap->pitch + p * 4 + 3]; - - if ((cr | cg | cb) == 0) continue; - drawPixel(i, j, cr, cg, cb, ca); - } - } - break; + // case FT_PIXEL_MODE_BGRA: + // x_max = x + bitmap->width/2; + // for (i = x, p = 0; i < x_max; i++, p++) { + // for (j = y, q = 0; j < y_max; j++, q++) { + // if (i < 0 || j < 0 || i >= 854 || j >= 480) continue; + // u8 cb = bitmap->buffer[q * bitmap->pitch + p * 4]; + // u8 cg = bitmap->buffer[q * bitmap->pitch + p * 4 + 1]; + // u8 cr = bitmap->buffer[q * bitmap->pitch + p * 4 + 2]; + // u8 ca = bitmap->buffer[q * bitmap->pitch + p * 4 + 3]; + // + // if ((cr | cg | cb) == 0) continue; + // drawPixel(i, j, cr, cg, cb, ca); + // } + // } + // break; } } @@ -507,7 +507,7 @@ int ttfStringWidth(char *string, s8 part) { continue; } - error = FT_Load_Glyph(face, glyph_index, FT_LOAD_BITMAP_METRICS_ONLY); + error = FT_Load_Glyph(face, glyph_index, 1/*FT_LOAD_BITMAP_METRICS_ONLY*/); if (error) continue; diff --git a/src/lib_easy.c b/src/lib_easy.c index d7a6bbe..d3bc592 100644 --- a/src/lib_easy.c +++ b/src/lib_easy.c @@ -3,6 +3,10 @@ int vpadError = -1; VPADData vpad; +s32 padErrors[4]; +u32 padTypes[4]; +KPADData pads[4]; + int screen_buf0_size = 0; int screen_buf1_size = 0; @@ -20,19 +24,61 @@ void ScreenInit() { initDraw(screenBuffer, screen_buf0_size, screen_buf1_size); } +void pingControllers() { + for (int i = 0; i < 4; i++) { + padErrors[i] = WPADProbe(i, &padTypes[i]); + } +} + void updatePressedButtons() { VPADRead(0, &vpad, 1, &vpadError); - buttons_pressed = vpad.btns_d; + buttons_pressed[0] = vpad.btns_d; + + pingControllers(); + for (int i = 0; i < 4; i++) { + if (padErrors[i] == 0) { + KPADRead(i, &pads[i], 1); + if (pads[i].device_type < 2) { + buttons_pressed[i + 1] = pads[i].btns_d; + } else { + buttons_pressed[i + 1] = pads[i].classic.btns_d; + } + } + } } void updateHeldButtons() { VPADRead(0, &vpad, 1, &vpadError); - buttons_hold = vpad.btns_h; + buttons_hold[0] = vpad.btns_h; + + pingControllers(); + for (int i = 0; i < 4; i++) { + if (padErrors[i] == 0) { + KPADRead(i, &pads[i], 1); + if (pads[i].device_type < 2) { + buttons_hold[i + 1] = pads[i].btns_h; + } else { + buttons_hold[i + 1] = pads[i].classic.btns_h; + } + } + } } void updateReleasedButtons() { VPADRead(0, &vpad, 1, &vpadError); - buttons_released = vpad.btns_r; + buttons_released[0] = vpad.btns_r; + + pingControllers(); + for (int i = 0; i < 4; i++) { + if (padErrors[i] == 0) { + KPADRead(i, &pads[i], 1); + if (pads[i].device_type < 2) { + buttons_released[i + 1] = pads[i].btns_r; + } else { + buttons_released[i + 1] = pads[i].classic.btns_r; + } + } + } } bool stickPos(u8 stick, f32 value) { @@ -56,16 +102,883 @@ bool stickPos(u8 stick, f32 value) { } } +bool isWiimote(KPADData *padData){ + return padData->device_type == 0 || padData->device_type == 1 || padData->device_type == 5 || padData->device_type == 6; +} + +bool isClassicController(KPADData *padData){ + return padData->device_type == 2 || padData->device_type == 7; +} + +bool isProController(KPADData *padData){ + return padData->device_type == 31; +} + int isPressed(int button) { - return (buttons_pressed&button); + //VPad buttons + switch (button) { + case PAD_BUTTON_A: + if (buttons_pressed[0] & VPAD_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_pressed[0] & VPAD_BUTTON_B) return 1; + break; + + case PAD_BUTTON_X: + if (buttons_pressed[0] & VPAD_BUTTON_X) return 1; + break; + + case PAD_BUTTON_Y: + if (buttons_pressed[0] & VPAD_BUTTON_Y) return 1; + break; + + case PAD_BUTTON_UP: + if (buttons_pressed[0] & VPAD_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_pressed[0] & VPAD_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_pressed[0] & VPAD_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_pressed[0] & VPAD_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_pressed[0] & VPAD_BUTTON_L) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_pressed[0] & VPAD_BUTTON_R) return 1; + break; + + case PAD_BUTTON_ZL: + if (buttons_pressed[0] & VPAD_BUTTON_ZL) return 1; + break; + + case PAD_BUTTON_ZR: + if (buttons_pressed[0] & VPAD_BUTTON_ZR) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_pressed[0] & VPAD_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_pressed[0] & VPAD_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_pressed[0] & VPAD_BUTTON_HOME) return 1; + break; + + case PAD_BUTTON_SYNC: + if (buttons_pressed[0] & VPAD_BUTTON_SYNC) return 1; + break; + + case PAD_BUTTON_STICK_L: + if (buttons_pressed[0] & VPAD_BUTTON_L) return 1; + break; + + case PAD_BUTTON_STICK_R: + if (buttons_pressed[0] & VPAD_BUTTON_STICK_R) return 1; + break; + + case PAD_BUTTON_TV: + if (buttons_pressed[0] & VPAD_BUTTON_TV) return 1; + break; + + default: + break; + } + + //Buttons handled by the padscore library + for (int i = 0; i < 4; i++) { + if (padErrors[i] == 0) { + if (isWiimote(&pads[i])) { + switch (button) { + case PAD_BUTTON_UP: + if (buttons_pressed[i + 1] & WPAD_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_pressed[i + 1] & WPAD_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_pressed[i + 1] & WPAD_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_pressed[i + 1] & WPAD_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_A: + if (buttons_pressed[i + 1] & WPAD_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_pressed[i + 1] & WPAD_BUTTON_B) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_pressed[i + 1] & WPAD_BUTTON_1) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_pressed[i + 1] & WPAD_BUTTON_2) return 1; + break; + + case PAD_BUTTON_1: + if (buttons_pressed[i + 1] & WPAD_BUTTON_1) return 1; + break; + + case PAD_BUTTON_2: + if (buttons_pressed[i + 1] & WPAD_BUTTON_2) return 1; + break; + + case PAD_BUTTON_Z: + if (buttons_pressed[i + 1] & WPAD_BUTTON_Z) return 1; + break; + + case PAD_BUTTON_C: + if (buttons_pressed[i + 1] & WPAD_BUTTON_C) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_pressed[i + 1] & WPAD_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_pressed[i + 1] & WPAD_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_pressed[i + 1] & WPAD_BUTTON_HOME) return 1; + break; + } + } + else if (isClassicController(&pads[i])) { + switch (button) { + case PAD_BUTTON_UP: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_A: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_B) return 1; + break; + + case PAD_BUTTON_X: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_X) return 1; + break; + + case PAD_BUTTON_Y: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_Y) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_L) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_R) return 1; + break; + + case PAD_BUTTON_ZL: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_ZL) return 1; + break; + + case PAD_BUTTON_ZR: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_ZR) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_HOME) return 1; + break; + } + } + else if (isProController(&pads[i])) { + switch (button) { + case PAD_BUTTON_UP: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_A: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_B) return 1; + break; + + case PAD_BUTTON_X: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_X) return 1; + break; + + case PAD_BUTTON_Y: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_Y) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_pressed[i + 1] & WPAD_PRO_TRIGGER_L) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_pressed[i + 1] & WPAD_PRO_TRIGGER_R) return 1; + break; + + case PAD_BUTTON_ZL: + if (buttons_pressed[i + 1] & WPAD_PRO_TRIGGER_ZL) return 1; + break; + + case PAD_BUTTON_ZR: + if (buttons_pressed[i + 1] & WPAD_PRO_TRIGGER_ZR) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_HOME) return 1; + break; + + case PAD_BUTTON_STICK_L: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; + break; + + case PAD_BUTTON_STICK_R: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; + break; + } + } + } + } + + return 0; } int isHeld(int button) { - return (buttons_hold&button); + //VPad buttons + switch (button) { + case PAD_BUTTON_A: + if (buttons_hold[0] & VPAD_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_hold[0] & VPAD_BUTTON_B) return 1; + break; + + case PAD_BUTTON_X: + if (buttons_hold[0] & VPAD_BUTTON_X) return 1; + break; + + case PAD_BUTTON_Y: + if (buttons_hold[0] & VPAD_BUTTON_Y) return 1; + break; + + case PAD_BUTTON_UP: + if (buttons_hold[0] & VPAD_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_hold[0] & VPAD_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_hold[0] & VPAD_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_hold[0] & VPAD_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_hold[0] & VPAD_BUTTON_L) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_hold[0] & VPAD_BUTTON_R) return 1; + break; + + case PAD_BUTTON_ZL: + if (buttons_hold[0] & VPAD_BUTTON_ZL) return 1; + break; + + case PAD_BUTTON_ZR: + if (buttons_hold[0] & VPAD_BUTTON_ZR) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_hold[0] & VPAD_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_hold[0] & VPAD_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_hold[0] & VPAD_BUTTON_HOME) return 1; + break; + + case PAD_BUTTON_SYNC: + if (buttons_hold[0] & VPAD_BUTTON_SYNC) return 1; + break; + + case PAD_BUTTON_STICK_L: + if (buttons_hold[0] & VPAD_BUTTON_L) return 1; + break; + + case PAD_BUTTON_STICK_R: + if (buttons_hold[0] & VPAD_BUTTON_STICK_R) return 1; + break; + + case PAD_BUTTON_TV: + if (buttons_hold[0] & VPAD_BUTTON_TV) return 1; + break; + + default: + break; + } + + //Buttons handled by the padscore library + for (int i = 0; i < 4; i++) { + if (padErrors[i] == 0) { + if (isWiimote(&pads[i])) { + switch (button) { + case PAD_BUTTON_UP: + if (buttons_hold[i + 1] & WPAD_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_hold[i + 1] & WPAD_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_hold[i + 1] & WPAD_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_hold[i + 1] & WPAD_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_A: + if (buttons_hold[i + 1] & WPAD_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_hold[i + 1] & WPAD_BUTTON_B) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_hold[i + 1] & WPAD_BUTTON_1) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_hold[i + 1] & WPAD_BUTTON_2) return 1; + break; + + case PAD_BUTTON_1: + if (buttons_hold[i + 1] & WPAD_BUTTON_1) return 1; + break; + + case PAD_BUTTON_2: + if (buttons_hold[i + 1] & WPAD_BUTTON_2) return 1; + break; + + case PAD_BUTTON_Z: + if (buttons_hold[i + 1] & WPAD_BUTTON_Z) return 1; + break; + + case PAD_BUTTON_C: + if (buttons_hold[i + 1] & WPAD_BUTTON_C) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_hold[i + 1] & WPAD_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_hold[i + 1] & WPAD_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_hold[i + 1] & WPAD_BUTTON_HOME) return 1; + break; + } + } + else if (isClassicController(&pads[i])) { + switch (button) { + case PAD_BUTTON_UP: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_A: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_B) return 1; + break; + + case PAD_BUTTON_X: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_X) return 1; + break; + + case PAD_BUTTON_Y: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_Y) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_L) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_R) return 1; + break; + + case PAD_BUTTON_ZL: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_ZL) return 1; + break; + + case PAD_BUTTON_ZR: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_ZR) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_HOME) return 1; + break; + } + } + else if (isProController(&pads[i])) { + switch (button) { + case PAD_BUTTON_UP: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_A: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_B) return 1; + break; + + case PAD_BUTTON_X: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_X) return 1; + break; + + case PAD_BUTTON_Y: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_Y) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_hold[i + 1] & WPAD_PRO_TRIGGER_L) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_hold[i + 1] & WPAD_PRO_TRIGGER_R) return 1; + break; + + case PAD_BUTTON_ZL: + if (buttons_hold[i + 1] & WPAD_PRO_TRIGGER_ZL) return 1; + break; + + case PAD_BUTTON_ZR: + if (buttons_hold[i + 1] & WPAD_PRO_TRIGGER_ZR) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_HOME) return 1; + break; + + case PAD_BUTTON_STICK_L: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; + break; + + case PAD_BUTTON_STICK_R: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; + break; + } + } + } + } + + return 0; } int isReleased(int button) { - return (buttons_released&button); + //VPad buttons + switch (button) { + case PAD_BUTTON_A: + if (buttons_released[0] & VPAD_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_released[0] & VPAD_BUTTON_B) return 1; + break; + + case PAD_BUTTON_X: + if (buttons_released[0] & VPAD_BUTTON_X) return 1; + break; + + case PAD_BUTTON_Y: + if (buttons_released[0] & VPAD_BUTTON_Y) return 1; + break; + + case PAD_BUTTON_UP: + if (buttons_released[0] & VPAD_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_released[0] & VPAD_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_released[0] & VPAD_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_released[0] & VPAD_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_released[0] & VPAD_BUTTON_L) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_released[0] & VPAD_BUTTON_R) return 1; + break; + + case PAD_BUTTON_ZL: + if (buttons_released[0] & VPAD_BUTTON_ZL) return 1; + break; + + case PAD_BUTTON_ZR: + if (buttons_released[0] & VPAD_BUTTON_ZR) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_released[0] & VPAD_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_released[0] & VPAD_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_released[0] & VPAD_BUTTON_HOME) return 1; + break; + + case PAD_BUTTON_SYNC: + if (buttons_released[0] & VPAD_BUTTON_SYNC) return 1; + break; + + case PAD_BUTTON_STICK_L: + if (buttons_released[0] & VPAD_BUTTON_L) return 1; + break; + + case PAD_BUTTON_STICK_R: + if (buttons_released[0] & VPAD_BUTTON_STICK_R) return 1; + break; + + case PAD_BUTTON_TV: + if (buttons_released[0] & VPAD_BUTTON_TV) return 1; + break; + + default: + break; + } + + //Buttons handled by the padscore library + for (int i = 0; i < 4; i++) { + if (padErrors[i] == 0) { + if (isWiimote(&pads[i])) { + switch (button) { + case PAD_BUTTON_UP: + if (buttons_released[i + 1] & WPAD_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_released[i + 1] & WPAD_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_released[i + 1] & WPAD_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_released[i + 1] & WPAD_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_A: + if (buttons_released[i + 1] & WPAD_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_released[i + 1] & WPAD_BUTTON_B) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_released[i + 1] & WPAD_BUTTON_1) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_released[i + 1] & WPAD_BUTTON_2) return 1; + break; + + case PAD_BUTTON_1: + if (buttons_released[i + 1] & WPAD_BUTTON_1) return 1; + break; + + case PAD_BUTTON_2: + if (buttons_released[i + 1] & WPAD_BUTTON_2) return 1; + break; + + case PAD_BUTTON_Z: + if (buttons_released[i + 1] & WPAD_BUTTON_Z) return 1; + break; + + case PAD_BUTTON_C: + if (buttons_released[i + 1] & WPAD_BUTTON_C) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_released[i + 1] & WPAD_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_released[i + 1] & WPAD_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_released[i + 1] & WPAD_BUTTON_HOME) return 1; + break; + } + } + else if (isClassicController(&pads[i])) { + switch (button) { + case PAD_BUTTON_UP: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_A: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_B) return 1; + break; + + case PAD_BUTTON_X: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_X) return 1; + break; + + case PAD_BUTTON_Y: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_Y) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_L) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_R) return 1; + break; + + case PAD_BUTTON_ZL: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_ZL) return 1; + break; + + case PAD_BUTTON_ZR: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_ZR) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_HOME) return 1; + break; + } + } + else if (isProController(&pads[i])) { + switch (button) { + case PAD_BUTTON_UP: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_A: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_B) return 1; + break; + + case PAD_BUTTON_X: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_X) return 1; + break; + + case PAD_BUTTON_Y: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_Y) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_released[i + 1] & WPAD_PRO_TRIGGER_L) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_released[i + 1] & WPAD_PRO_TRIGGER_R) return 1; + break; + + case PAD_BUTTON_ZL: + if (buttons_released[i + 1] & WPAD_PRO_TRIGGER_ZL) return 1; + break; + + case PAD_BUTTON_ZR: + if (buttons_released[i + 1] & WPAD_PRO_TRIGGER_ZR) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_HOME) return 1; + break; + + case PAD_BUTTON_STICK_L: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; + break; + + case PAD_BUTTON_STICK_R: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; + break; + } + } + } + } + + return 0; } void uInit() { @@ -85,6 +998,8 @@ void uInit() { memoryInitialize(); //You probably shouldn't care about this for now :P VPADInit(); //Init GamePad input library (needed for getting gamepad input) + KPADInit(); //Init controler input library for other wireless inputs + WPADInit(); ScreenInit(); //Init OSScreen (all the complex stuff is in easyfunctions.h :P ) } diff --git a/src/lib_easy.h b/src/lib_easy.h index e8f46ab..8eaac0d 100644 --- a/src/lib_easy.h +++ b/src/lib_easy.h @@ -38,16 +38,46 @@ #include "utils/utils.h" #include "common/common.h" +enum buttons { + PAD_BUTTON_A, + PAD_BUTTON_B, + PAD_BUTTON_X, + PAD_BUTTON_Y, + PAD_BUTTON_UP, + PAD_BUTTON_DOWN, + PAD_BUTTON_LEFT, + PAD_BUTTON_RIGHT, + PAD_BUTTON_L, + PAD_BUTTON_R, + PAD_BUTTON_ZL, + PAD_BUTTON_ZR, + PAD_BUTTON_PLUS, + PAD_BUTTON_MINUS, + PAD_BUTTON_Z, + PAD_BUTTON_C, + PAD_BUTTON_STICK_L, + PAD_BUTTON_STICK_R, + PAD_BUTTON_HOME, + PAD_BUTTON_SYNC, + PAD_BUTTON_TV, + PAD_BUTTON_1, + PAD_BUTTON_2 +}; + unsigned char *screenBuffer; -uint32_t buttons_hold; //Held buttons -uint32_t buttons_pressed; //Pressed buttons -uint32_t buttons_released; //Released buttons +uint32_t buttons_hold[5]; //Held buttons +uint32_t buttons_pressed[5]; //Pressed buttons +uint32_t buttons_released[5]; //Released buttons void ScreenInit(); +void pingControllers(); void updatePressedButtons(); void updateHeldButtons(); void updateReleasedButtons(); bool stickPos(u8 stick, f32 value); +bool isWiimote(KPADData *padData); +bool isClassicController(KPADData *padData); +bool isProController(KPADData *padData); int isPressed(int button); int isHeld(int button); int isReleased(int button); diff --git a/src/main.c b/src/main.c index 520d962..8610299 100644 --- a/src/main.c +++ b/src/main.c @@ -684,13 +684,13 @@ int Menu_Main(void) { updatePressedButtons(); updateHeldButtons(); - if (isPressed(VPAD_BUTTON_DOWN) || isHeld(VPAD_BUTTON_DOWN) || stickPos(1, -0.7) || stickPos(3, -0.7)) { + if (isPressed(PAD_BUTTON_DOWN) || isHeld(PAD_BUTTON_DOWN) || stickPos(1, -0.7) || stickPos(3, -0.7)) { if (entrycount <= 14) cursor = (cursor + 1) % entrycount; else if (cursor < 6) cursor++; else if ((cursor + scroll + 1) % entrycount) scroll++; else cursor = scroll = 0; os_usleep(100000); - } else if (isPressed(VPAD_BUTTON_UP) || isHeld(VPAD_BUTTON_UP) || stickPos(1, 0.7) || stickPos(3, 0.7)) { + } else if (isPressed(PAD_BUTTON_UP) || isHeld(PAD_BUTTON_UP) || stickPos(1, 0.7) || stickPos(3, 0.7)) { if (scroll > 0) cursor -= (cursor>6) ? 1 : 0 * (scroll--); else if (cursor > 0) cursor--; else if (entrycount > 14) scroll = entrycount - (cursor = 6) - 1; @@ -698,7 +698,7 @@ int Menu_Main(void) { os_usleep(100000); } - if (isPressed(VPAD_BUTTON_LEFT) || isHeld(VPAD_BUTTON_LEFT) || stickPos(0, -0.7) || stickPos(2, -0.7)) { + if (isPressed(PAD_BUTTON_LEFT) || isHeld(PAD_BUTTON_LEFT) || stickPos(0, -0.7) || stickPos(2, -0.7)) { if (menu==3) { if (task == 5) { switch(cursor) { @@ -746,7 +746,7 @@ int Menu_Main(void) { } } os_usleep(100000); - } else if (isPressed(VPAD_BUTTON_RIGHT) || isHeld(VPAD_BUTTON_RIGHT) || stickPos(0, 0.7) || stickPos(2, 0.7)) { + } else if (isPressed(PAD_BUTTON_RIGHT) || isHeld(PAD_BUTTON_RIGHT) || stickPos(0, 0.7) || stickPos(2, 0.7)) { if (menu == 3) { if (task == 5) { switch(cursor) { @@ -796,7 +796,7 @@ int Menu_Main(void) { os_usleep(100000); } - if (isPressed(VPAD_BUTTON_R)) { + if (isPressed(PAD_BUTTON_R)) { if (menu == 1) { tsort = (tsort + 1) % 4; qsort(titles, count, sizeof(Title), titleSort); @@ -806,7 +806,7 @@ int Menu_Main(void) { } } - if (isPressed(VPAD_BUTTON_L)) { + if (isPressed(PAD_BUTTON_L)) { if ((menu==1) && (tsort > 0)) { sorta *= -1; qsort(titles, count, sizeof(Title), titleSort); @@ -816,7 +816,7 @@ int Menu_Main(void) { } } - if (isPressed(VPAD_BUTTON_A)) { + if (isPressed(PAD_BUTTON_A)) { clearBuffers(); if (menu < 3) { if (menu == 0) { @@ -928,7 +928,7 @@ int Menu_Main(void) { } break; } } - } else if (isPressed(VPAD_BUTTON_B) && menu > 0) { + } else if (isPressed(PAD_BUTTON_B) && menu > 0) { clearBuffers(); menu--; cursor = scroll = 0; @@ -938,7 +938,7 @@ int Menu_Main(void) { } if (menu == 2) cursor = cursort; } - if (isPressed(VPAD_BUTTON_HOME)) break; + if (isPressed(PAD_BUTTON_HOME)) break; } if (tgaBufDRC) free(tgaBufDRC); diff --git a/src/savemng.c b/src/savemng.c index 2d31355..b567fd5 100644 --- a/src/savemng.c +++ b/src/savemng.c @@ -300,8 +300,8 @@ bool promptConfirm(Style st, const char* question) { int ret = 0; while(1) { updatePressedButtons(); - if (isPressed(VPAD_BUTTON_A | VPAD_BUTTON_B | VPAD_BUTTON_HOME)) { - ret = isPressed(VPAD_BUTTON_A); + if (isPressed(PAD_BUTTON_A | PAD_BUTTON_B | PAD_BUTTON_HOME)) { + ret = isPressed(PAD_BUTTON_A); break; } } From 431f55fe3425a3673ff4791772bf7c734650c5ac Mon Sep 17 00:00:00 2001 From: jakobkg Date: Thu, 1 Mar 2018 18:28:46 +0100 Subject: [PATCH 2/5] Implemented a check for if any button is pressed The parameter isPressed(PAD_BUTTON_ANY) replaces the old isPressed(0xFFFF), fixing the last issues with this branch --- src/lib_easy.c | 23 ++++++++++++++++++++++- src/lib_easy.h | 3 ++- src/main.c | 2 +- src/savemng.c | 4 ++-- 4 files changed, 27 insertions(+), 5 deletions(-) diff --git a/src/lib_easy.c b/src/lib_easy.c index d3bc592..5e67b45 100644 --- a/src/lib_easy.c +++ b/src/lib_easy.c @@ -115,6 +115,12 @@ bool isProController(KPADData *padData){ } int isPressed(int button) { + //Check for any button at all + if (button == PAD_BUTTON_ANY) { + for (int i = 0; i < 5; i++) { + if (buttons_pressed[i] > 0) return 1; + } + } //VPad buttons switch (button) { case PAD_BUTTON_A: @@ -398,12 +404,21 @@ int isPressed(int button) { } } } + else { + log_print("No padscore controllers found"); + } } return 0; } int isHeld(int button) { + //Check for any button at all + if (button == PAD_BUTTON_ANY) { + for (int i = 0; i < 5; i++) { + if (buttons_hold[i] > 0) return 1; + } + } //VPad buttons switch (button) { case PAD_BUTTON_A: @@ -693,6 +708,12 @@ int isHeld(int button) { } int isReleased(int button) { + //Check for any button at all + if (button == PAD_BUTTON_ANY) { + for (int i = 0; i < 5; i++) { + if (buttons_released[i] > 0) return 1; + } + } //VPad buttons switch (button) { case PAD_BUTTON_A: @@ -998,7 +1019,7 @@ void uInit() { memoryInitialize(); //You probably shouldn't care about this for now :P VPADInit(); //Init GamePad input library (needed for getting gamepad input) - KPADInit(); //Init controler input library for other wireless inputs + KPADInit(); //Init controller input library for other wireless inputs WPADInit(); ScreenInit(); //Init OSScreen (all the complex stuff is in easyfunctions.h :P ) } diff --git a/src/lib_easy.h b/src/lib_easy.h index 8eaac0d..506576c 100644 --- a/src/lib_easy.h +++ b/src/lib_easy.h @@ -61,7 +61,8 @@ enum buttons { PAD_BUTTON_SYNC, PAD_BUTTON_TV, PAD_BUTTON_1, - PAD_BUTTON_2 + PAD_BUTTON_2, + PAD_BUTTON_ANY }; unsigned char *screenBuffer; diff --git a/src/main.c b/src/main.c index 8610299..1202c84 100644 --- a/src/main.c +++ b/src/main.c @@ -679,7 +679,7 @@ int Menu_Main(void) { while(1) { updatePressedButtons(); updateHeldButtons(); - if (isPressed(0xFFFF) || isHeld(0xFFFF) || stickPos(4, 0.7)) break; + if (isPressed(PAD_BUTTON_ANY) || isHeld(PAD_BUTTON_ANY) || stickPos(4, 0.7)) break; } updatePressedButtons(); updateHeldButtons(); diff --git a/src/savemng.c b/src/savemng.c index b567fd5..3f61b48 100644 --- a/src/savemng.c +++ b/src/savemng.c @@ -300,7 +300,7 @@ bool promptConfirm(Style st, const char* question) { int ret = 0; while(1) { updatePressedButtons(); - if (isPressed(PAD_BUTTON_A | PAD_BUTTON_B | PAD_BUTTON_HOME)) { + if (isPressed(PAD_BUTTON_ANY)) { ret = isPressed(PAD_BUTTON_A); break; } @@ -330,7 +330,7 @@ void promptError(const char* message, ...) { va_end(va); while(1) { updatePressedButtons(); - if (isPressed(0xFFFF)) break; + if (isPressed(PAD_BUTTON_ANY)) break; } } From 58d2974195487dd89cf74526e258146e6176e324 Mon Sep 17 00:00:00 2001 From: jakobkg Date: Fri, 2 Mar 2018 10:18:41 +0100 Subject: [PATCH 3/5] Combined handling of pro and classic controllers Turns out the two use the esact same bitmapping for everything, with the pro controller having two extra bits for R3 and L3. Merged the two for slightly shorter code. --- src/lib_easy.c | 285 +++++++++++-------------------------------------- 1 file changed, 62 insertions(+), 223 deletions(-) diff --git a/src/lib_easy.c b/src/lib_easy.c index 5e67b45..5832090 100644 --- a/src/lib_easy.c +++ b/src/lib_easy.c @@ -38,11 +38,16 @@ void updatePressedButtons() { for (int i = 0; i < 4; i++) { if (padErrors[i] == 0) { KPADRead(i, &pads[i], 1); - if (pads[i].device_type < 2) { + if (isWiimote(&pads[i])) { buttons_pressed[i + 1] = pads[i].btns_d; - } else { + } + else if (isClassicController(&pads[i])) { buttons_pressed[i + 1] = pads[i].classic.btns_d; } + else if (isProController(&pads[i])) { + buttons_pressed[i + 1] = pads[i].pro.btns_d; + } + } } } @@ -55,10 +60,14 @@ void updateHeldButtons() { for (int i = 0; i < 4; i++) { if (padErrors[i] == 0) { KPADRead(i, &pads[i], 1); - if (pads[i].device_type < 2) { - buttons_hold[i + 1] = pads[i].btns_h; - } else { - buttons_hold[i + 1] = pads[i].classic.btns_h; + if (isWiimote(&pads[i])) { + buttons_pressed[i + 1] = pads[i].btns_h; + } + else if (isClassicController(&pads[i])) { + buttons_pressed[i + 1] = pads[i].classic.btns_h; + } + else if (isProController(&pads[i])) { + buttons_pressed[i + 1] = pads[i].pro.btns_h; } } } @@ -72,10 +81,14 @@ void updateReleasedButtons() { for (int i = 0; i < 4; i++) { if (padErrors[i] == 0) { KPADRead(i, &pads[i], 1); - if (pads[i].device_type < 2) { - buttons_released[i + 1] = pads[i].btns_r; - } else { - buttons_released[i + 1] = pads[i].classic.btns_r; + if (isWiimote(&pads[i])) { + buttons_pressed[i + 1] = pads[i].btns_r; + } + else if (isClassicController(&pads[i])) { + buttons_pressed[i + 1] = pads[i].classic.btns_r; + } + else if (isProController(&pads[i])) { + buttons_pressed[i + 1] = pads[i].pro.btns_r; } } } @@ -269,7 +282,9 @@ int isPressed(int button) { break; } } - else if (isClassicController(&pads[i])) { + //Turns out the Pro Controller and Classic Controller have almost the exact same mapping + //Except for the Pro Controller having clicky sticks + else if (isClassicController(&pads[i]) || isProController(&pads[i])) { switch (button) { case PAD_BUTTON_UP: if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_UP) return 1; @@ -331,82 +346,20 @@ int isPressed(int button) { if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_HOME) return 1; break; } - } - else if (isProController(&pads[i])) { - switch (button) { - case PAD_BUTTON_UP: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_UP) return 1; - break; + //Here, we handle the aforementioned clicky sticks + if (isProController(&pads[i])) { + switch (button) { + case PAD_BUTTON_STICK_L: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; + break; - case PAD_BUTTON_DOWN: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_A: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_B) return 1; - break; - - case PAD_BUTTON_X: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_X) return 1; - break; - - case PAD_BUTTON_Y: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_Y) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_pressed[i + 1] & WPAD_PRO_TRIGGER_L) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_pressed[i + 1] & WPAD_PRO_TRIGGER_R) return 1; - break; - - case PAD_BUTTON_ZL: - if (buttons_pressed[i + 1] & WPAD_PRO_TRIGGER_ZL) return 1; - break; - - case PAD_BUTTON_ZR: - if (buttons_pressed[i + 1] & WPAD_PRO_TRIGGER_ZR) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_HOME) return 1; - break; - - case PAD_BUTTON_STICK_L: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; - break; - - case PAD_BUTTON_STICK_R: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; - break; + case PAD_BUTTON_STICK_R: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; + break; + } } } } - else { - log_print("No padscore controllers found"); - } } return 0; @@ -567,7 +520,9 @@ int isHeld(int button) { break; } } - else if (isClassicController(&pads[i])) { + //Turns out the Pro Controller and Classic Controller have almost the exact same mapping + //Except for the Pro Controller having clicky sticks + else if (isClassicController(&pads[i]) || isProController(&pads[i])) { switch (button) { case PAD_BUTTON_UP: if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_UP) return 1; @@ -629,76 +584,17 @@ int isHeld(int button) { if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_HOME) return 1; break; } - } - else if (isProController(&pads[i])) { - switch (button) { - case PAD_BUTTON_UP: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_UP) return 1; - break; + //Here, we handle the aforementioned clicky sticks + if (isProController(&pads[i])) { + switch (button) { + case PAD_BUTTON_STICK_L: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; + break; - case PAD_BUTTON_DOWN: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_A: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_B) return 1; - break; - - case PAD_BUTTON_X: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_X) return 1; - break; - - case PAD_BUTTON_Y: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_Y) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_hold[i + 1] & WPAD_PRO_TRIGGER_L) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_hold[i + 1] & WPAD_PRO_TRIGGER_R) return 1; - break; - - case PAD_BUTTON_ZL: - if (buttons_hold[i + 1] & WPAD_PRO_TRIGGER_ZL) return 1; - break; - - case PAD_BUTTON_ZR: - if (buttons_hold[i + 1] & WPAD_PRO_TRIGGER_ZR) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_HOME) return 1; - break; - - case PAD_BUTTON_STICK_L: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; - break; - - case PAD_BUTTON_STICK_R: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; - break; + case PAD_BUTTON_STICK_R: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; + break; + } } } } @@ -862,7 +758,9 @@ int isReleased(int button) { break; } } - else if (isClassicController(&pads[i])) { + //Turns out the Pro Controller and Classic Controller have almost the exact same mapping + //Except for the Pro Controller having clicky sticks + else if (isClassicController(&pads[i]) || isProController(&pads[i])) { switch (button) { case PAD_BUTTON_UP: if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_UP) return 1; @@ -924,76 +822,17 @@ int isReleased(int button) { if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_HOME) return 1; break; } - } - else if (isProController(&pads[i])) { - switch (button) { - case PAD_BUTTON_UP: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_UP) return 1; - break; + //Here, we handle the aforementioned clicky sticks + if (isProController(&pads[i])) { + switch (button) { + case PAD_BUTTON_STICK_L: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; + break; - case PAD_BUTTON_DOWN: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_A: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_B) return 1; - break; - - case PAD_BUTTON_X: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_X) return 1; - break; - - case PAD_BUTTON_Y: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_Y) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_released[i + 1] & WPAD_PRO_TRIGGER_L) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_released[i + 1] & WPAD_PRO_TRIGGER_R) return 1; - break; - - case PAD_BUTTON_ZL: - if (buttons_released[i + 1] & WPAD_PRO_TRIGGER_ZL) return 1; - break; - - case PAD_BUTTON_ZR: - if (buttons_released[i + 1] & WPAD_PRO_TRIGGER_ZR) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_HOME) return 1; - break; - - case PAD_BUTTON_STICK_L: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; - break; - - case PAD_BUTTON_STICK_R: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; - break; + case PAD_BUTTON_STICK_R: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; + break; + } } } } From 087c4cddd8024c666673309ef50409f24c394bc6 Mon Sep 17 00:00:00 2001 From: jakobkg Date: Fri, 2 Mar 2018 10:48:38 +0100 Subject: [PATCH 4/5] Restored lib_easy and moved controller things to own files Maybe bloating lib_easy isn't a great idea, I've restored it and commented out all the controller bits, and moved my controller things to new files. --- src/controllers.c | 827 +++++++++++++++++++++++++++++++++++++++++++ src/controllers.h | 50 +++ src/lib_easy.c | 871 +++------------------------------------------- src/lib_easy.h | 51 +-- src/savemng.h | 1 + 5 files changed, 937 insertions(+), 863 deletions(-) create mode 100644 src/controllers.c create mode 100644 src/controllers.h diff --git a/src/controllers.c b/src/controllers.c new file mode 100644 index 0000000..e2bbc61 --- /dev/null +++ b/src/controllers.c @@ -0,0 +1,827 @@ +//Based on code from lib_easy, current stickPos() is straight borrowed from there + +#include "controllers.h" + +int vpadError = -1; +VPADData vpad; + +s32 padErrors[4]; +u32 padTypes[4]; +KPADData pads[4]; + +void pingControllers() { + for (int i = 0; i < 4; i++) { + padErrors[i] = WPADProbe(i, &padTypes[i]); + } +} + +void updatePressedButtons() { + VPADRead(0, &vpad, 1, &vpadError); + buttons_pressed[0] = vpad.btns_d; + + pingControllers(); + for (int i = 0; i < 4; i++) { + if (padErrors[i] == 0) { + KPADRead(i, &pads[i], 1); + if (isWiimote(&pads[i])) { + buttons_pressed[i + 1] = pads[i].btns_d; + } + else if (isClassicController(&pads[i])) { + buttons_pressed[i + 1] = pads[i].classic.btns_d; + } + else if (isProController(&pads[i])) { + buttons_pressed[i + 1] = pads[i].pro.btns_d; + } + + } + } +} + +void updateHeldButtons() { + VPADRead(0, &vpad, 1, &vpadError); + buttons_hold[0] = vpad.btns_h; + + pingControllers(); + for (int i = 0; i < 4; i++) { + if (padErrors[i] == 0) { + KPADRead(i, &pads[i], 1); + if (isWiimote(&pads[i])) { + buttons_hold[i + 1] = pads[i].btns_h; + } + else if (isClassicController(&pads[i])) { + buttons_hold[i + 1] = pads[i].classic.btns_h; + } + else if (isProController(&pads[i])) { + buttons_hold[i + 1] = pads[i].pro.btns_h; + } + } + } +} + +void updateReleasedButtons() { + VPADRead(0, &vpad, 1, &vpadError); + buttons_released[0] = vpad.btns_r; + + pingControllers(); + for (int i = 0; i < 4; i++) { + if (padErrors[i] == 0) { + KPADRead(i, &pads[i], 1); + if (isWiimote(&pads[i])) { + buttons_released[i + 1] = pads[i].btns_r; + } + else if (isClassicController(&pads[i])) { + buttons_released[i + 1] = pads[i].classic.btns_r; + } + else if (isProController(&pads[i])) { + buttons_released[i + 1] = pads[i].pro.btns_r; + } + } + } +} + +bool stickPos(u8 stick, f32 value) { + switch(stick) { + case 0 : + return (value > 0) ? (vpad.lstick.x > value): (vpad.lstick.x < value); + case 1 : + return (value > 0) ? (vpad.lstick.y > value): (vpad.lstick.y < value); + case 2 : + return (value > 0) ? (vpad.rstick.x > value): (vpad.rstick.x < value); + case 3 : + return (value > 0) ? (vpad.rstick.y > value): (vpad.rstick.y < value); + case 4 : + return ((vpad.lstick.x > value) || (vpad.lstick.x < -value)) || \ + ((vpad.lstick.y > value) || (vpad.lstick.y < -value)) || \ + ((vpad.rstick.x > value) || (vpad.rstick.x < -value)) || \ + ((vpad.rstick.y > value) || (vpad.rstick.y < -value)); + + default : + return 0; + } +} + +bool isWiimote(KPADData *padData){ + return padData->device_type == 0 || padData->device_type == 1 || padData->device_type == 5 || padData->device_type == 6; +} + +bool isClassicController(KPADData *padData){ + return padData->device_type == 2 || padData->device_type == 7; +} + +bool isProController(KPADData *padData){ + return padData->device_type == 31; +} + +int isPressed(int button) { + //Check for any button at all + if (button == PAD_BUTTON_ANY) { + for (int i = 0; i < 5; i++) { + if (buttons_pressed[i] > 0) return 1; + } + } + //VPad buttons + switch (button) { + case PAD_BUTTON_A: + if (buttons_pressed[0] & VPAD_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_pressed[0] & VPAD_BUTTON_B) return 1; + break; + + case PAD_BUTTON_X: + if (buttons_pressed[0] & VPAD_BUTTON_X) return 1; + break; + + case PAD_BUTTON_Y: + if (buttons_pressed[0] & VPAD_BUTTON_Y) return 1; + break; + + case PAD_BUTTON_UP: + if (buttons_pressed[0] & VPAD_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_pressed[0] & VPAD_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_pressed[0] & VPAD_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_pressed[0] & VPAD_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_pressed[0] & VPAD_BUTTON_L) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_pressed[0] & VPAD_BUTTON_R) return 1; + break; + + case PAD_BUTTON_ZL: + if (buttons_pressed[0] & VPAD_BUTTON_ZL) return 1; + break; + + case PAD_BUTTON_ZR: + if (buttons_pressed[0] & VPAD_BUTTON_ZR) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_pressed[0] & VPAD_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_pressed[0] & VPAD_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_pressed[0] & VPAD_BUTTON_HOME) return 1; + break; + + case PAD_BUTTON_SYNC: + if (buttons_pressed[0] & VPAD_BUTTON_SYNC) return 1; + break; + + case PAD_BUTTON_STICK_L: + if (buttons_pressed[0] & VPAD_BUTTON_L) return 1; + break; + + case PAD_BUTTON_STICK_R: + if (buttons_pressed[0] & VPAD_BUTTON_STICK_R) return 1; + break; + + case PAD_BUTTON_TV: + if (buttons_pressed[0] & VPAD_BUTTON_TV) return 1; + break; + + default: + break; + } + + //Buttons handled by the padscore library + for (int i = 0; i < 4; i++) { + if (padErrors[i] == 0) { + if (isWiimote(&pads[i])) { + switch (button) { + case PAD_BUTTON_UP: + if (buttons_pressed[i + 1] & WPAD_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_pressed[i + 1] & WPAD_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_pressed[i + 1] & WPAD_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_pressed[i + 1] & WPAD_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_A: + if (buttons_pressed[i + 1] & WPAD_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_pressed[i + 1] & WPAD_BUTTON_B) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_pressed[i + 1] & WPAD_BUTTON_1) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_pressed[i + 1] & WPAD_BUTTON_2) return 1; + break; + + case PAD_BUTTON_1: + if (buttons_pressed[i + 1] & WPAD_BUTTON_1) return 1; + break; + + case PAD_BUTTON_2: + if (buttons_pressed[i + 1] & WPAD_BUTTON_2) return 1; + break; + + case PAD_BUTTON_Z: + if (buttons_pressed[i + 1] & WPAD_BUTTON_Z) return 1; + break; + + case PAD_BUTTON_C: + if (buttons_pressed[i + 1] & WPAD_BUTTON_C) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_pressed[i + 1] & WPAD_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_pressed[i + 1] & WPAD_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_pressed[i + 1] & WPAD_BUTTON_HOME) return 1; + break; + } + } + //Turns out the Pro Controller and Classic Controller have almost the exact same mapping + //Except for the Pro Controller having clicky sticks + else if (isClassicController(&pads[i]) || isProController(&pads[i])) { + switch (button) { + case PAD_BUTTON_UP: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_A: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_B) return 1; + break; + + case PAD_BUTTON_X: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_X) return 1; + break; + + case PAD_BUTTON_Y: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_Y) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_L) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_R) return 1; + break; + + case PAD_BUTTON_ZL: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_ZL) return 1; + break; + + case PAD_BUTTON_ZR: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_ZR) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_HOME) return 1; + break; + } + //Here, we handle the aforementioned clicky sticks + if (isProController(&pads[i])) { + switch (button) { + case PAD_BUTTON_STICK_L: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; + break; + + case PAD_BUTTON_STICK_R: + if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; + break; + } + } + } + } + } + + return 0; +} + +int isHeld(int button) { + //Check for any button at all + if (button == PAD_BUTTON_ANY) { + for (int i = 0; i < 5; i++) { + if (buttons_hold[i] > 0) return 1; + } + } + //VPad buttons + switch (button) { + case PAD_BUTTON_A: + if (buttons_hold[0] & VPAD_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_hold[0] & VPAD_BUTTON_B) return 1; + break; + + case PAD_BUTTON_X: + if (buttons_hold[0] & VPAD_BUTTON_X) return 1; + break; + + case PAD_BUTTON_Y: + if (buttons_hold[0] & VPAD_BUTTON_Y) return 1; + break; + + case PAD_BUTTON_UP: + if (buttons_hold[0] & VPAD_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_hold[0] & VPAD_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_hold[0] & VPAD_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_hold[0] & VPAD_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_hold[0] & VPAD_BUTTON_L) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_hold[0] & VPAD_BUTTON_R) return 1; + break; + + case PAD_BUTTON_ZL: + if (buttons_hold[0] & VPAD_BUTTON_ZL) return 1; + break; + + case PAD_BUTTON_ZR: + if (buttons_hold[0] & VPAD_BUTTON_ZR) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_hold[0] & VPAD_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_hold[0] & VPAD_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_hold[0] & VPAD_BUTTON_HOME) return 1; + break; + + case PAD_BUTTON_SYNC: + if (buttons_hold[0] & VPAD_BUTTON_SYNC) return 1; + break; + + case PAD_BUTTON_STICK_L: + if (buttons_hold[0] & VPAD_BUTTON_L) return 1; + break; + + case PAD_BUTTON_STICK_R: + if (buttons_hold[0] & VPAD_BUTTON_STICK_R) return 1; + break; + + case PAD_BUTTON_TV: + if (buttons_hold[0] & VPAD_BUTTON_TV) return 1; + break; + + default: + break; + } + + //Buttons handled by the padscore library + for (int i = 0; i < 4; i++) { + if (padErrors[i] == 0) { + if (isWiimote(&pads[i])) { + switch (button) { + case PAD_BUTTON_UP: + if (buttons_hold[i + 1] & WPAD_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_hold[i + 1] & WPAD_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_hold[i + 1] & WPAD_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_hold[i + 1] & WPAD_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_A: + if (buttons_hold[i + 1] & WPAD_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_hold[i + 1] & WPAD_BUTTON_B) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_hold[i + 1] & WPAD_BUTTON_1) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_hold[i + 1] & WPAD_BUTTON_2) return 1; + break; + + case PAD_BUTTON_1: + if (buttons_hold[i + 1] & WPAD_BUTTON_1) return 1; + break; + + case PAD_BUTTON_2: + if (buttons_hold[i + 1] & WPAD_BUTTON_2) return 1; + break; + + case PAD_BUTTON_Z: + if (buttons_hold[i + 1] & WPAD_BUTTON_Z) return 1; + break; + + case PAD_BUTTON_C: + if (buttons_hold[i + 1] & WPAD_BUTTON_C) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_hold[i + 1] & WPAD_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_hold[i + 1] & WPAD_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_hold[i + 1] & WPAD_BUTTON_HOME) return 1; + break; + } + } + //Turns out the Pro Controller and Classic Controller have almost the exact same mapping + //Except for the Pro Controller having clicky sticks + else if (isClassicController(&pads[i]) || isProController(&pads[i])) { + switch (button) { + case PAD_BUTTON_UP: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_A: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_B) return 1; + break; + + case PAD_BUTTON_X: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_X) return 1; + break; + + case PAD_BUTTON_Y: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_Y) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_L) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_R) return 1; + break; + + case PAD_BUTTON_ZL: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_ZL) return 1; + break; + + case PAD_BUTTON_ZR: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_ZR) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_HOME) return 1; + break; + } + //Here, we handle the aforementioned clicky sticks + if (isProController(&pads[i])) { + switch (button) { + case PAD_BUTTON_STICK_L: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; + break; + + case PAD_BUTTON_STICK_R: + if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; + break; + } + } + } + } + } + + return 0; +} + +int isReleased(int button) { + //Check for any button at all + if (button == PAD_BUTTON_ANY) { + for (int i = 0; i < 5; i++) { + if (buttons_released[i] > 0) return 1; + } + } + //VPad buttons + switch (button) { + case PAD_BUTTON_A: + if (buttons_released[0] & VPAD_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_released[0] & VPAD_BUTTON_B) return 1; + break; + + case PAD_BUTTON_X: + if (buttons_released[0] & VPAD_BUTTON_X) return 1; + break; + + case PAD_BUTTON_Y: + if (buttons_released[0] & VPAD_BUTTON_Y) return 1; + break; + + case PAD_BUTTON_UP: + if (buttons_released[0] & VPAD_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_released[0] & VPAD_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_released[0] & VPAD_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_released[0] & VPAD_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_released[0] & VPAD_BUTTON_L) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_released[0] & VPAD_BUTTON_R) return 1; + break; + + case PAD_BUTTON_ZL: + if (buttons_released[0] & VPAD_BUTTON_ZL) return 1; + break; + + case PAD_BUTTON_ZR: + if (buttons_released[0] & VPAD_BUTTON_ZR) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_released[0] & VPAD_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_released[0] & VPAD_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_released[0] & VPAD_BUTTON_HOME) return 1; + break; + + case PAD_BUTTON_SYNC: + if (buttons_released[0] & VPAD_BUTTON_SYNC) return 1; + break; + + case PAD_BUTTON_STICK_L: + if (buttons_released[0] & VPAD_BUTTON_L) return 1; + break; + + case PAD_BUTTON_STICK_R: + if (buttons_released[0] & VPAD_BUTTON_STICK_R) return 1; + break; + + case PAD_BUTTON_TV: + if (buttons_released[0] & VPAD_BUTTON_TV) return 1; + break; + + default: + break; + } + + //Buttons handled by the padscore library + for (int i = 0; i < 4; i++) { + if (padErrors[i] == 0) { + if (isWiimote(&pads[i])) { + switch (button) { + case PAD_BUTTON_UP: + if (buttons_released[i + 1] & WPAD_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_released[i + 1] & WPAD_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_released[i + 1] & WPAD_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_released[i + 1] & WPAD_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_A: + if (buttons_released[i + 1] & WPAD_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_released[i + 1] & WPAD_BUTTON_B) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_released[i + 1] & WPAD_BUTTON_1) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_released[i + 1] & WPAD_BUTTON_2) return 1; + break; + + case PAD_BUTTON_1: + if (buttons_released[i + 1] & WPAD_BUTTON_1) return 1; + break; + + case PAD_BUTTON_2: + if (buttons_released[i + 1] & WPAD_BUTTON_2) return 1; + break; + + case PAD_BUTTON_Z: + if (buttons_released[i + 1] & WPAD_BUTTON_Z) return 1; + break; + + case PAD_BUTTON_C: + if (buttons_released[i + 1] & WPAD_BUTTON_C) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_released[i + 1] & WPAD_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_released[i + 1] & WPAD_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_released[i + 1] & WPAD_BUTTON_HOME) return 1; + break; + } + } + //Turns out the Pro Controller and Classic Controller have almost the exact same mapping + //Except for the Pro Controller having clicky sticks + else if (isClassicController(&pads[i]) || isProController(&pads[i])) { + switch (button) { + case PAD_BUTTON_UP: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_UP) return 1; + break; + + case PAD_BUTTON_DOWN: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_DOWN) return 1; + break; + + case PAD_BUTTON_LEFT: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_LEFT) return 1; + break; + + case PAD_BUTTON_RIGHT: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_RIGHT) return 1; + break; + + case PAD_BUTTON_A: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_A) return 1; + break; + + case PAD_BUTTON_B: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_B) return 1; + break; + + case PAD_BUTTON_X: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_X) return 1; + break; + + case PAD_BUTTON_Y: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_Y) return 1; + break; + + case PAD_BUTTON_L: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_L) return 1; + break; + + case PAD_BUTTON_R: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_R) return 1; + break; + + case PAD_BUTTON_ZL: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_ZL) return 1; + break; + + case PAD_BUTTON_ZR: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_ZR) return 1; + break; + + case PAD_BUTTON_PLUS: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_PLUS) return 1; + break; + + case PAD_BUTTON_MINUS: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_MINUS) return 1; + break; + + case PAD_BUTTON_HOME: + if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_HOME) return 1; + break; + } + //Here, we handle the aforementioned clicky sticks + if (isProController(&pads[i])) { + switch (button) { + case PAD_BUTTON_STICK_L: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; + break; + + case PAD_BUTTON_STICK_R: + if (buttons_released[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; + break; + } + } + } + } + } + + return 0; +} diff --git a/src/controllers.h b/src/controllers.h new file mode 100644 index 0000000..0caed2b --- /dev/null +++ b/src/controllers.h @@ -0,0 +1,50 @@ +#ifndef CONTROLLERS_H +#define CONTROLLERS_H + +#include "dynamic_libs/padscore_functions.h" +#include "dynamic_libs/vpad_functions.h" + +enum buttons { + PAD_BUTTON_A, + PAD_BUTTON_B, + PAD_BUTTON_X, + PAD_BUTTON_Y, + PAD_BUTTON_UP, + PAD_BUTTON_DOWN, + PAD_BUTTON_LEFT, + PAD_BUTTON_RIGHT, + PAD_BUTTON_L, + PAD_BUTTON_R, + PAD_BUTTON_ZL, + PAD_BUTTON_ZR, + PAD_BUTTON_PLUS, + PAD_BUTTON_MINUS, + PAD_BUTTON_Z, + PAD_BUTTON_C, + PAD_BUTTON_STICK_L, + PAD_BUTTON_STICK_R, + PAD_BUTTON_HOME, + PAD_BUTTON_SYNC, + PAD_BUTTON_TV, + PAD_BUTTON_1, + PAD_BUTTON_2, + PAD_BUTTON_ANY +}; + +uint32_t buttons_hold[5]; //Held buttons +uint32_t buttons_pressed[5]; //Pressed buttons +uint32_t buttons_released[5]; //Released buttons + +void pingControllers(); +void updatePressedButtons(); +void updateHeldButtons(); +void updateReleasedButtons(); +bool stickPos(u8 stick, f32 value); +bool isWiimote(KPADData *padData); +bool isClassicController(KPADData *padData); +bool isProController(KPADData *padData); +int isPressed(int button); +int isHeld(int button); +int isReleased(int button); + +#endif //CONTROLLERS_H diff --git a/src/lib_easy.c b/src/lib_easy.c index 5832090..2760672 100644 --- a/src/lib_easy.c +++ b/src/lib_easy.c @@ -1,11 +1,7 @@ #include "lib_easy.h" -int vpadError = -1; -VPADData vpad; - -s32 padErrors[4]; -u32 padTypes[4]; -KPADData pads[4]; +// int vpadError = -1; +// VPADData vpad; int screen_buf0_size = 0; int screen_buf1_size = 0; @@ -24,822 +20,53 @@ void ScreenInit() { initDraw(screenBuffer, screen_buf0_size, screen_buf1_size); } -void pingControllers() { - for (int i = 0; i < 4; i++) { - padErrors[i] = WPADProbe(i, &padTypes[i]); - } -} - -void updatePressedButtons() { - VPADRead(0, &vpad, 1, &vpadError); - buttons_pressed[0] = vpad.btns_d; - - pingControllers(); - for (int i = 0; i < 4; i++) { - if (padErrors[i] == 0) { - KPADRead(i, &pads[i], 1); - if (isWiimote(&pads[i])) { - buttons_pressed[i + 1] = pads[i].btns_d; - } - else if (isClassicController(&pads[i])) { - buttons_pressed[i + 1] = pads[i].classic.btns_d; - } - else if (isProController(&pads[i])) { - buttons_pressed[i + 1] = pads[i].pro.btns_d; - } - - } - } -} - -void updateHeldButtons() { - VPADRead(0, &vpad, 1, &vpadError); - buttons_hold[0] = vpad.btns_h; - - pingControllers(); - for (int i = 0; i < 4; i++) { - if (padErrors[i] == 0) { - KPADRead(i, &pads[i], 1); - if (isWiimote(&pads[i])) { - buttons_pressed[i + 1] = pads[i].btns_h; - } - else if (isClassicController(&pads[i])) { - buttons_pressed[i + 1] = pads[i].classic.btns_h; - } - else if (isProController(&pads[i])) { - buttons_pressed[i + 1] = pads[i].pro.btns_h; - } - } - } -} - -void updateReleasedButtons() { - VPADRead(0, &vpad, 1, &vpadError); - buttons_released[0] = vpad.btns_r; - - pingControllers(); - for (int i = 0; i < 4; i++) { - if (padErrors[i] == 0) { - KPADRead(i, &pads[i], 1); - if (isWiimote(&pads[i])) { - buttons_pressed[i + 1] = pads[i].btns_r; - } - else if (isClassicController(&pads[i])) { - buttons_pressed[i + 1] = pads[i].classic.btns_r; - } - else if (isProController(&pads[i])) { - buttons_pressed[i + 1] = pads[i].pro.btns_r; - } - } - } -} - -bool stickPos(u8 stick, f32 value) { - switch(stick) { - case 0 : - return (value > 0) ? (vpad.lstick.x > value): (vpad.lstick.x < value); - case 1 : - return (value > 0) ? (vpad.lstick.y > value): (vpad.lstick.y < value); - case 2 : - return (value > 0) ? (vpad.rstick.x > value): (vpad.rstick.x < value); - case 3 : - return (value > 0) ? (vpad.rstick.y > value): (vpad.rstick.y < value); - case 4 : - return ((vpad.lstick.x > value) || (vpad.lstick.x < -value)) || \ - ((vpad.lstick.y > value) || (vpad.lstick.y < -value)) || \ - ((vpad.rstick.x > value) || (vpad.rstick.x < -value)) || \ - ((vpad.rstick.y > value) || (vpad.rstick.y < -value)); - - default : - return 0; - } -} - -bool isWiimote(KPADData *padData){ - return padData->device_type == 0 || padData->device_type == 1 || padData->device_type == 5 || padData->device_type == 6; -} - -bool isClassicController(KPADData *padData){ - return padData->device_type == 2 || padData->device_type == 7; -} - -bool isProController(KPADData *padData){ - return padData->device_type == 31; -} - -int isPressed(int button) { - //Check for any button at all - if (button == PAD_BUTTON_ANY) { - for (int i = 0; i < 5; i++) { - if (buttons_pressed[i] > 0) return 1; - } - } - //VPad buttons - switch (button) { - case PAD_BUTTON_A: - if (buttons_pressed[0] & VPAD_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_pressed[0] & VPAD_BUTTON_B) return 1; - break; - - case PAD_BUTTON_X: - if (buttons_pressed[0] & VPAD_BUTTON_X) return 1; - break; - - case PAD_BUTTON_Y: - if (buttons_pressed[0] & VPAD_BUTTON_Y) return 1; - break; - - case PAD_BUTTON_UP: - if (buttons_pressed[0] & VPAD_BUTTON_UP) return 1; - break; - - case PAD_BUTTON_DOWN: - if (buttons_pressed[0] & VPAD_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_pressed[0] & VPAD_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_pressed[0] & VPAD_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_pressed[0] & VPAD_BUTTON_L) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_pressed[0] & VPAD_BUTTON_R) return 1; - break; - - case PAD_BUTTON_ZL: - if (buttons_pressed[0] & VPAD_BUTTON_ZL) return 1; - break; - - case PAD_BUTTON_ZR: - if (buttons_pressed[0] & VPAD_BUTTON_ZR) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_pressed[0] & VPAD_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_pressed[0] & VPAD_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_pressed[0] & VPAD_BUTTON_HOME) return 1; - break; - - case PAD_BUTTON_SYNC: - if (buttons_pressed[0] & VPAD_BUTTON_SYNC) return 1; - break; - - case PAD_BUTTON_STICK_L: - if (buttons_pressed[0] & VPAD_BUTTON_L) return 1; - break; - - case PAD_BUTTON_STICK_R: - if (buttons_pressed[0] & VPAD_BUTTON_STICK_R) return 1; - break; - - case PAD_BUTTON_TV: - if (buttons_pressed[0] & VPAD_BUTTON_TV) return 1; - break; - - default: - break; - } - - //Buttons handled by the padscore library - for (int i = 0; i < 4; i++) { - if (padErrors[i] == 0) { - if (isWiimote(&pads[i])) { - switch (button) { - case PAD_BUTTON_UP: - if (buttons_pressed[i + 1] & WPAD_BUTTON_UP) return 1; - break; - - case PAD_BUTTON_DOWN: - if (buttons_pressed[i + 1] & WPAD_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_pressed[i + 1] & WPAD_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_pressed[i + 1] & WPAD_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_A: - if (buttons_pressed[i + 1] & WPAD_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_pressed[i + 1] & WPAD_BUTTON_B) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_pressed[i + 1] & WPAD_BUTTON_1) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_pressed[i + 1] & WPAD_BUTTON_2) return 1; - break; - - case PAD_BUTTON_1: - if (buttons_pressed[i + 1] & WPAD_BUTTON_1) return 1; - break; - - case PAD_BUTTON_2: - if (buttons_pressed[i + 1] & WPAD_BUTTON_2) return 1; - break; - - case PAD_BUTTON_Z: - if (buttons_pressed[i + 1] & WPAD_BUTTON_Z) return 1; - break; - - case PAD_BUTTON_C: - if (buttons_pressed[i + 1] & WPAD_BUTTON_C) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_pressed[i + 1] & WPAD_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_pressed[i + 1] & WPAD_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_pressed[i + 1] & WPAD_BUTTON_HOME) return 1; - break; - } - } - //Turns out the Pro Controller and Classic Controller have almost the exact same mapping - //Except for the Pro Controller having clicky sticks - else if (isClassicController(&pads[i]) || isProController(&pads[i])) { - switch (button) { - case PAD_BUTTON_UP: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_UP) return 1; - break; - - case PAD_BUTTON_DOWN: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_A: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_B) return 1; - break; - - case PAD_BUTTON_X: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_X) return 1; - break; - - case PAD_BUTTON_Y: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_Y) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_L) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_R) return 1; - break; - - case PAD_BUTTON_ZL: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_ZL) return 1; - break; - - case PAD_BUTTON_ZR: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_ZR) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_HOME) return 1; - break; - } - //Here, we handle the aforementioned clicky sticks - if (isProController(&pads[i])) { - switch (button) { - case PAD_BUTTON_STICK_L: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; - break; - - case PAD_BUTTON_STICK_R: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; - break; - } - } - } - } - } - - return 0; -} - -int isHeld(int button) { - //Check for any button at all - if (button == PAD_BUTTON_ANY) { - for (int i = 0; i < 5; i++) { - if (buttons_hold[i] > 0) return 1; - } - } - //VPad buttons - switch (button) { - case PAD_BUTTON_A: - if (buttons_hold[0] & VPAD_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_hold[0] & VPAD_BUTTON_B) return 1; - break; - - case PAD_BUTTON_X: - if (buttons_hold[0] & VPAD_BUTTON_X) return 1; - break; - - case PAD_BUTTON_Y: - if (buttons_hold[0] & VPAD_BUTTON_Y) return 1; - break; - - case PAD_BUTTON_UP: - if (buttons_hold[0] & VPAD_BUTTON_UP) return 1; - break; - - case PAD_BUTTON_DOWN: - if (buttons_hold[0] & VPAD_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_hold[0] & VPAD_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_hold[0] & VPAD_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_hold[0] & VPAD_BUTTON_L) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_hold[0] & VPAD_BUTTON_R) return 1; - break; - - case PAD_BUTTON_ZL: - if (buttons_hold[0] & VPAD_BUTTON_ZL) return 1; - break; - - case PAD_BUTTON_ZR: - if (buttons_hold[0] & VPAD_BUTTON_ZR) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_hold[0] & VPAD_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_hold[0] & VPAD_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_hold[0] & VPAD_BUTTON_HOME) return 1; - break; - - case PAD_BUTTON_SYNC: - if (buttons_hold[0] & VPAD_BUTTON_SYNC) return 1; - break; - - case PAD_BUTTON_STICK_L: - if (buttons_hold[0] & VPAD_BUTTON_L) return 1; - break; - - case PAD_BUTTON_STICK_R: - if (buttons_hold[0] & VPAD_BUTTON_STICK_R) return 1; - break; - - case PAD_BUTTON_TV: - if (buttons_hold[0] & VPAD_BUTTON_TV) return 1; - break; - - default: - break; - } - - //Buttons handled by the padscore library - for (int i = 0; i < 4; i++) { - if (padErrors[i] == 0) { - if (isWiimote(&pads[i])) { - switch (button) { - case PAD_BUTTON_UP: - if (buttons_hold[i + 1] & WPAD_BUTTON_UP) return 1; - break; - - case PAD_BUTTON_DOWN: - if (buttons_hold[i + 1] & WPAD_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_hold[i + 1] & WPAD_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_hold[i + 1] & WPAD_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_A: - if (buttons_hold[i + 1] & WPAD_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_hold[i + 1] & WPAD_BUTTON_B) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_hold[i + 1] & WPAD_BUTTON_1) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_hold[i + 1] & WPAD_BUTTON_2) return 1; - break; - - case PAD_BUTTON_1: - if (buttons_hold[i + 1] & WPAD_BUTTON_1) return 1; - break; - - case PAD_BUTTON_2: - if (buttons_hold[i + 1] & WPAD_BUTTON_2) return 1; - break; - - case PAD_BUTTON_Z: - if (buttons_hold[i + 1] & WPAD_BUTTON_Z) return 1; - break; - - case PAD_BUTTON_C: - if (buttons_hold[i + 1] & WPAD_BUTTON_C) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_hold[i + 1] & WPAD_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_hold[i + 1] & WPAD_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_hold[i + 1] & WPAD_BUTTON_HOME) return 1; - break; - } - } - //Turns out the Pro Controller and Classic Controller have almost the exact same mapping - //Except for the Pro Controller having clicky sticks - else if (isClassicController(&pads[i]) || isProController(&pads[i])) { - switch (button) { - case PAD_BUTTON_UP: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_UP) return 1; - break; - - case PAD_BUTTON_DOWN: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_A: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_B) return 1; - break; - - case PAD_BUTTON_X: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_X) return 1; - break; - - case PAD_BUTTON_Y: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_Y) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_L) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_R) return 1; - break; - - case PAD_BUTTON_ZL: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_ZL) return 1; - break; - - case PAD_BUTTON_ZR: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_ZR) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_HOME) return 1; - break; - } - //Here, we handle the aforementioned clicky sticks - if (isProController(&pads[i])) { - switch (button) { - case PAD_BUTTON_STICK_L: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; - break; - - case PAD_BUTTON_STICK_R: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; - break; - } - } - } - } - } - - return 0; -} - -int isReleased(int button) { - //Check for any button at all - if (button == PAD_BUTTON_ANY) { - for (int i = 0; i < 5; i++) { - if (buttons_released[i] > 0) return 1; - } - } - //VPad buttons - switch (button) { - case PAD_BUTTON_A: - if (buttons_released[0] & VPAD_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_released[0] & VPAD_BUTTON_B) return 1; - break; - - case PAD_BUTTON_X: - if (buttons_released[0] & VPAD_BUTTON_X) return 1; - break; - - case PAD_BUTTON_Y: - if (buttons_released[0] & VPAD_BUTTON_Y) return 1; - break; - - case PAD_BUTTON_UP: - if (buttons_released[0] & VPAD_BUTTON_UP) return 1; - break; - - case PAD_BUTTON_DOWN: - if (buttons_released[0] & VPAD_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_released[0] & VPAD_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_released[0] & VPAD_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_released[0] & VPAD_BUTTON_L) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_released[0] & VPAD_BUTTON_R) return 1; - break; - - case PAD_BUTTON_ZL: - if (buttons_released[0] & VPAD_BUTTON_ZL) return 1; - break; - - case PAD_BUTTON_ZR: - if (buttons_released[0] & VPAD_BUTTON_ZR) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_released[0] & VPAD_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_released[0] & VPAD_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_released[0] & VPAD_BUTTON_HOME) return 1; - break; - - case PAD_BUTTON_SYNC: - if (buttons_released[0] & VPAD_BUTTON_SYNC) return 1; - break; - - case PAD_BUTTON_STICK_L: - if (buttons_released[0] & VPAD_BUTTON_L) return 1; - break; - - case PAD_BUTTON_STICK_R: - if (buttons_released[0] & VPAD_BUTTON_STICK_R) return 1; - break; - - case PAD_BUTTON_TV: - if (buttons_released[0] & VPAD_BUTTON_TV) return 1; - break; - - default: - break; - } - - //Buttons handled by the padscore library - for (int i = 0; i < 4; i++) { - if (padErrors[i] == 0) { - if (isWiimote(&pads[i])) { - switch (button) { - case PAD_BUTTON_UP: - if (buttons_released[i + 1] & WPAD_BUTTON_UP) return 1; - break; - - case PAD_BUTTON_DOWN: - if (buttons_released[i + 1] & WPAD_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_released[i + 1] & WPAD_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_released[i + 1] & WPAD_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_A: - if (buttons_released[i + 1] & WPAD_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_released[i + 1] & WPAD_BUTTON_B) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_released[i + 1] & WPAD_BUTTON_1) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_released[i + 1] & WPAD_BUTTON_2) return 1; - break; - - case PAD_BUTTON_1: - if (buttons_released[i + 1] & WPAD_BUTTON_1) return 1; - break; - - case PAD_BUTTON_2: - if (buttons_released[i + 1] & WPAD_BUTTON_2) return 1; - break; - - case PAD_BUTTON_Z: - if (buttons_released[i + 1] & WPAD_BUTTON_Z) return 1; - break; - - case PAD_BUTTON_C: - if (buttons_released[i + 1] & WPAD_BUTTON_C) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_released[i + 1] & WPAD_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_released[i + 1] & WPAD_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_released[i + 1] & WPAD_BUTTON_HOME) return 1; - break; - } - } - //Turns out the Pro Controller and Classic Controller have almost the exact same mapping - //Except for the Pro Controller having clicky sticks - else if (isClassicController(&pads[i]) || isProController(&pads[i])) { - switch (button) { - case PAD_BUTTON_UP: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_UP) return 1; - break; - - case PAD_BUTTON_DOWN: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_A: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_B) return 1; - break; - - case PAD_BUTTON_X: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_X) return 1; - break; - - case PAD_BUTTON_Y: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_Y) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_L) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_R) return 1; - break; - - case PAD_BUTTON_ZL: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_ZL) return 1; - break; - - case PAD_BUTTON_ZR: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_ZR) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_HOME) return 1; - break; - } - //Here, we handle the aforementioned clicky sticks - if (isProController(&pads[i])) { - switch (button) { - case PAD_BUTTON_STICK_L: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; - break; - - case PAD_BUTTON_STICK_R: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; - break; - } - } - } - } - } - - return 0; -} +// void updatePressedButtons() { +// VPADRead(0, &vpad, 1, &vpadError); +// buttons_pressed = vpad.btns_d; +// } + +// void updateHeldButtons() { +// VPADRead(0, &vpad, 1, &vpadError); +// buttons_hold = vpad.btns_h; +// } + +// void updateReleasedButtons() { +// VPADRead(0, &vpad, 1, &vpadError); +// buttons_released = vpad.btns_r; +// } + +// bool stickPos(u8 stick, f32 value) { +// switch(stick) { +// case 0 : +// return (value > 0) ? (vpad.lstick.x > value): (vpad.lstick.x < value); +// case 1 : +// return (value > 0) ? (vpad.lstick.y > value): (vpad.lstick.y < value); +// case 2 : +// return (value > 0) ? (vpad.rstick.x > value): (vpad.rstick.x < value); +// case 3 : +// return (value > 0) ? (vpad.rstick.y > value): (vpad.rstick.y < value); +// case 4 : +// return ((vpad.lstick.x > value) || (vpad.lstick.x < -value)) || \ +// ((vpad.lstick.y > value) || (vpad.lstick.y < -value)) || \ +// ((vpad.rstick.x > value) || (vpad.rstick.x < -value)) || \ +// ((vpad.rstick.y > value) || (vpad.rstick.y < -value)); +// +// default : +// return 0; +// } +// } + +// int isPressed(int button) { +// return (buttons_pressed&button); +// } + +// int isHeld(int button) { +// return (buttons_hold&button); +// } + +// int isReleased(int button) { +// return (buttons_released&button); +// } void uInit() { //--Initialize every function pointer-- (byebye FindExport :D) diff --git a/src/lib_easy.h b/src/lib_easy.h index 506576c..fdb2eba 100644 --- a/src/lib_easy.h +++ b/src/lib_easy.h @@ -38,50 +38,19 @@ #include "utils/utils.h" #include "common/common.h" -enum buttons { - PAD_BUTTON_A, - PAD_BUTTON_B, - PAD_BUTTON_X, - PAD_BUTTON_Y, - PAD_BUTTON_UP, - PAD_BUTTON_DOWN, - PAD_BUTTON_LEFT, - PAD_BUTTON_RIGHT, - PAD_BUTTON_L, - PAD_BUTTON_R, - PAD_BUTTON_ZL, - PAD_BUTTON_ZR, - PAD_BUTTON_PLUS, - PAD_BUTTON_MINUS, - PAD_BUTTON_Z, - PAD_BUTTON_C, - PAD_BUTTON_STICK_L, - PAD_BUTTON_STICK_R, - PAD_BUTTON_HOME, - PAD_BUTTON_SYNC, - PAD_BUTTON_TV, - PAD_BUTTON_1, - PAD_BUTTON_2, - PAD_BUTTON_ANY -}; - unsigned char *screenBuffer; -uint32_t buttons_hold[5]; //Held buttons -uint32_t buttons_pressed[5]; //Pressed buttons -uint32_t buttons_released[5]; //Released buttons +//uint32_t buttons_hold; //Held buttons +//uint32_t buttons_pressed; //Pressed buttons +//uint32_t buttons_released; //Released buttons void ScreenInit(); -void pingControllers(); -void updatePressedButtons(); -void updateHeldButtons(); -void updateReleasedButtons(); -bool stickPos(u8 stick, f32 value); -bool isWiimote(KPADData *padData); -bool isClassicController(KPADData *padData); -bool isProController(KPADData *padData); -int isPressed(int button); -int isHeld(int button); -int isReleased(int button); +// void updatePressedButtons(); +// void updateHeldButtons(); +// void updateReleasedButtons(); +// bool stickPos(u8 stick, f32 value); +// int isPressed(int button); +// int isHeld(int button); +// int isReleased(int button); void uInit(); void uDeInit(); diff --git a/src/savemng.h b/src/savemng.h index b01516a..7b588e2 100644 --- a/src/savemng.h +++ b/src/savemng.h @@ -10,6 +10,7 @@ #include "lib_easy.h" #include "draw.h" +#include "controllers.h" #define PATH_SIZE 0x400 From 6d5cbf9af5682c45e05e1feff1f8d246ca5c2494 Mon Sep 17 00:00:00 2001 From: jakobkg Date: Fri, 2 Mar 2018 20:09:33 +0100 Subject: [PATCH 5/5] Simplified the controller functions The three functions related to updating the arrays of buttons tates are now a single function, updateButtons. The three functions isPressed(), isHeld(), and isReleased() have been merged into a single function, checkButton() which takes parameters for which button to check and what state or event (PRESS, HOLD, RELEASE) to check for. --- src/controllers.c | 637 ++++++---------------------------------------- src/controllers.h | 17 +- src/main.c | 26 +- src/savemng.c | 10 +- 4 files changed, 101 insertions(+), 589 deletions(-) diff --git a/src/controllers.c b/src/controllers.c index e2bbc61..1509e1a 100644 --- a/src/controllers.c +++ b/src/controllers.c @@ -15,9 +15,11 @@ void pingControllers() { } } -void updatePressedButtons() { - VPADRead(0, &vpad, 1, &vpadError); - buttons_pressed[0] = vpad.btns_d; +void updateButtons() { + VPADRead(0, &vpad, 1, &vpadError); + buttons_pressed[0] = vpad.btns_d; + buttons_hold[0] = vpad.btns_h; + buttons_released[0] = vpad.btns_r; pingControllers(); for (int i = 0; i < 4; i++) { @@ -25,54 +27,17 @@ void updatePressedButtons() { KPADRead(i, &pads[i], 1); if (isWiimote(&pads[i])) { buttons_pressed[i + 1] = pads[i].btns_d; - } - else if (isClassicController(&pads[i])) { - buttons_pressed[i + 1] = pads[i].classic.btns_d; - } - else if (isProController(&pads[i])) { - buttons_pressed[i + 1] = pads[i].pro.btns_d; - } - - } - } -} - -void updateHeldButtons() { - VPADRead(0, &vpad, 1, &vpadError); - buttons_hold[0] = vpad.btns_h; - - pingControllers(); - for (int i = 0; i < 4; i++) { - if (padErrors[i] == 0) { - KPADRead(i, &pads[i], 1); - if (isWiimote(&pads[i])) { buttons_hold[i + 1] = pads[i].btns_h; - } - else if (isClassicController(&pads[i])) { - buttons_hold[i + 1] = pads[i].classic.btns_h; - } - else if (isProController(&pads[i])) { - buttons_hold[i + 1] = pads[i].pro.btns_h; - } - } - } -} - -void updateReleasedButtons() { - VPADRead(0, &vpad, 1, &vpadError); - buttons_released[0] = vpad.btns_r; - - pingControllers(); - for (int i = 0; i < 4; i++) { - if (padErrors[i] == 0) { - KPADRead(i, &pads[i], 1); - if (isWiimote(&pads[i])) { buttons_released[i + 1] = pads[i].btns_r; } else if (isClassicController(&pads[i])) { + buttons_pressed[i + 1] = pads[i].classic.btns_d; + buttons_hold[i + 1] = pads[i].classic.btns_h; buttons_released[i + 1] = pads[i].classic.btns_r; } else if (isProController(&pads[i])) { + buttons_pressed[i + 1] = pads[i].pro.btns_d; + buttons_hold[i + 1] = pads[i].pro.btns_h; buttons_released[i + 1] = pads[i].pro.btns_r; } } @@ -112,327 +77,109 @@ bool isProController(KPADData *padData){ return padData->device_type == 31; } -int isPressed(int button) { - //Check for any button at all - if (button == PAD_BUTTON_ANY) { - for (int i = 0; i < 5; i++) { - if (buttons_pressed[i] > 0) return 1; - } - } - //VPad buttons - switch (button) { - case PAD_BUTTON_A: - if (buttons_pressed[0] & VPAD_BUTTON_A) return 1; +int checkButton(int button, int state) { + uint32_t *stateArray; + + switch(state) { + case PRESS: + stateArray = &buttons_pressed; break; - case PAD_BUTTON_B: - if (buttons_pressed[0] & VPAD_BUTTON_B) return 1; + case HOLD: + stateArray = &buttons_hold; break; - case PAD_BUTTON_X: - if (buttons_pressed[0] & VPAD_BUTTON_X) return 1; - break; - - case PAD_BUTTON_Y: - if (buttons_pressed[0] & VPAD_BUTTON_Y) return 1; - break; - - case PAD_BUTTON_UP: - if (buttons_pressed[0] & VPAD_BUTTON_UP) return 1; - break; - - case PAD_BUTTON_DOWN: - if (buttons_pressed[0] & VPAD_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_pressed[0] & VPAD_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_pressed[0] & VPAD_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_pressed[0] & VPAD_BUTTON_L) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_pressed[0] & VPAD_BUTTON_R) return 1; - break; - - case PAD_BUTTON_ZL: - if (buttons_pressed[0] & VPAD_BUTTON_ZL) return 1; - break; - - case PAD_BUTTON_ZR: - if (buttons_pressed[0] & VPAD_BUTTON_ZR) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_pressed[0] & VPAD_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_pressed[0] & VPAD_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_pressed[0] & VPAD_BUTTON_HOME) return 1; - break; - - case PAD_BUTTON_SYNC: - if (buttons_pressed[0] & VPAD_BUTTON_SYNC) return 1; - break; - - case PAD_BUTTON_STICK_L: - if (buttons_pressed[0] & VPAD_BUTTON_L) return 1; - break; - - case PAD_BUTTON_STICK_R: - if (buttons_pressed[0] & VPAD_BUTTON_STICK_R) return 1; - break; - - case PAD_BUTTON_TV: - if (buttons_pressed[0] & VPAD_BUTTON_TV) return 1; + case RELEASE: + stateArray = &buttons_released; break; default: - break; + return 0; } - //Buttons handled by the padscore library - for (int i = 0; i < 4; i++) { - if (padErrors[i] == 0) { - if (isWiimote(&pads[i])) { - switch (button) { - case PAD_BUTTON_UP: - if (buttons_pressed[i + 1] & WPAD_BUTTON_UP) return 1; - break; - - case PAD_BUTTON_DOWN: - if (buttons_pressed[i + 1] & WPAD_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_pressed[i + 1] & WPAD_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_pressed[i + 1] & WPAD_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_A: - if (buttons_pressed[i + 1] & WPAD_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_pressed[i + 1] & WPAD_BUTTON_B) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_pressed[i + 1] & WPAD_BUTTON_1) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_pressed[i + 1] & WPAD_BUTTON_2) return 1; - break; - - case PAD_BUTTON_1: - if (buttons_pressed[i + 1] & WPAD_BUTTON_1) return 1; - break; - - case PAD_BUTTON_2: - if (buttons_pressed[i + 1] & WPAD_BUTTON_2) return 1; - break; - - case PAD_BUTTON_Z: - if (buttons_pressed[i + 1] & WPAD_BUTTON_Z) return 1; - break; - - case PAD_BUTTON_C: - if (buttons_pressed[i + 1] & WPAD_BUTTON_C) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_pressed[i + 1] & WPAD_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_pressed[i + 1] & WPAD_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_pressed[i + 1] & WPAD_BUTTON_HOME) return 1; - break; - } - } - //Turns out the Pro Controller and Classic Controller have almost the exact same mapping - //Except for the Pro Controller having clicky sticks - else if (isClassicController(&pads[i]) || isProController(&pads[i])) { - switch (button) { - case PAD_BUTTON_UP: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_UP) return 1; - break; - - case PAD_BUTTON_DOWN: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_A: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_B) return 1; - break; - - case PAD_BUTTON_X: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_X) return 1; - break; - - case PAD_BUTTON_Y: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_Y) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_L) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_R) return 1; - break; - - case PAD_BUTTON_ZL: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_ZL) return 1; - break; - - case PAD_BUTTON_ZR: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_ZR) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_pressed[i + 1] & WPAD_CLASSIC_BUTTON_HOME) return 1; - break; - } - //Here, we handle the aforementioned clicky sticks - if (isProController(&pads[i])) { - switch (button) { - case PAD_BUTTON_STICK_L: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; - break; - - case PAD_BUTTON_STICK_R: - if (buttons_pressed[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; - break; - } - } - } - } - } - - return 0; -} - -int isHeld(int button) { //Check for any button at all if (button == PAD_BUTTON_ANY) { for (int i = 0; i < 5; i++) { - if (buttons_hold[i] > 0) return 1; + if (stateArray[i] > 0) return 1; } } + //VPad buttons switch (button) { case PAD_BUTTON_A: - if (buttons_hold[0] & VPAD_BUTTON_A) return 1; + if (stateArray[0] & VPAD_BUTTON_A) return 1; break; case PAD_BUTTON_B: - if (buttons_hold[0] & VPAD_BUTTON_B) return 1; + if (stateArray[0] & VPAD_BUTTON_B) return 1; break; case PAD_BUTTON_X: - if (buttons_hold[0] & VPAD_BUTTON_X) return 1; + if (stateArray[0] & VPAD_BUTTON_X) return 1; break; case PAD_BUTTON_Y: - if (buttons_hold[0] & VPAD_BUTTON_Y) return 1; + if (stateArray[0] & VPAD_BUTTON_Y) return 1; break; case PAD_BUTTON_UP: - if (buttons_hold[0] & VPAD_BUTTON_UP) return 1; + if (stateArray[0] & VPAD_BUTTON_UP) return 1; break; case PAD_BUTTON_DOWN: - if (buttons_hold[0] & VPAD_BUTTON_DOWN) return 1; + if (stateArray[0] & VPAD_BUTTON_DOWN) return 1; break; case PAD_BUTTON_LEFT: - if (buttons_hold[0] & VPAD_BUTTON_LEFT) return 1; + if (stateArray[0] & VPAD_BUTTON_LEFT) return 1; break; case PAD_BUTTON_RIGHT: - if (buttons_hold[0] & VPAD_BUTTON_RIGHT) return 1; + if (stateArray[0] & VPAD_BUTTON_RIGHT) return 1; break; case PAD_BUTTON_L: - if (buttons_hold[0] & VPAD_BUTTON_L) return 1; + if (stateArray[0] & VPAD_BUTTON_L) return 1; break; case PAD_BUTTON_R: - if (buttons_hold[0] & VPAD_BUTTON_R) return 1; + if (stateArray[0] & VPAD_BUTTON_R) return 1; break; case PAD_BUTTON_ZL: - if (buttons_hold[0] & VPAD_BUTTON_ZL) return 1; + if (stateArray[0] & VPAD_BUTTON_ZL) return 1; break; case PAD_BUTTON_ZR: - if (buttons_hold[0] & VPAD_BUTTON_ZR) return 1; + if (stateArray[0] & VPAD_BUTTON_ZR) return 1; break; case PAD_BUTTON_PLUS: - if (buttons_hold[0] & VPAD_BUTTON_PLUS) return 1; + if (stateArray[0] & VPAD_BUTTON_PLUS) return 1; break; case PAD_BUTTON_MINUS: - if (buttons_hold[0] & VPAD_BUTTON_MINUS) return 1; + if (stateArray[0] & VPAD_BUTTON_MINUS) return 1; break; case PAD_BUTTON_HOME: - if (buttons_hold[0] & VPAD_BUTTON_HOME) return 1; + if (stateArray[0] & VPAD_BUTTON_HOME) return 1; break; case PAD_BUTTON_SYNC: - if (buttons_hold[0] & VPAD_BUTTON_SYNC) return 1; + if (stateArray[0] & VPAD_BUTTON_SYNC) return 1; break; case PAD_BUTTON_STICK_L: - if (buttons_hold[0] & VPAD_BUTTON_L) return 1; + if (stateArray[0] & VPAD_BUTTON_L) return 1; break; case PAD_BUTTON_STICK_R: - if (buttons_hold[0] & VPAD_BUTTON_STICK_R) return 1; + if (stateArray[0] & VPAD_BUTTON_STICK_R) return 1; break; case PAD_BUTTON_TV: - if (buttons_hold[0] & VPAD_BUTTON_TV) return 1; + if (stateArray[0] & VPAD_BUTTON_TV) return 1; break; default: @@ -445,63 +192,63 @@ int isHeld(int button) { if (isWiimote(&pads[i])) { switch (button) { case PAD_BUTTON_UP: - if (buttons_hold[i + 1] & WPAD_BUTTON_UP) return 1; + if (stateArray[i + 1] & WPAD_BUTTON_UP) return 1; break; case PAD_BUTTON_DOWN: - if (buttons_hold[i + 1] & WPAD_BUTTON_DOWN) return 1; + if (stateArray[i + 1] & WPAD_BUTTON_DOWN) return 1; break; case PAD_BUTTON_LEFT: - if (buttons_hold[i + 1] & WPAD_BUTTON_LEFT) return 1; + if (stateArray[i + 1] & WPAD_BUTTON_LEFT) return 1; break; case PAD_BUTTON_RIGHT: - if (buttons_hold[i + 1] & WPAD_BUTTON_RIGHT) return 1; + if (stateArray[i + 1] & WPAD_BUTTON_RIGHT) return 1; break; case PAD_BUTTON_A: - if (buttons_hold[i + 1] & WPAD_BUTTON_A) return 1; + if (stateArray[i + 1] & WPAD_BUTTON_A) return 1; break; case PAD_BUTTON_B: - if (buttons_hold[i + 1] & WPAD_BUTTON_B) return 1; + if (stateArray[i + 1] & WPAD_BUTTON_B) return 1; break; case PAD_BUTTON_L: - if (buttons_hold[i + 1] & WPAD_BUTTON_1) return 1; + if (stateArray[i + 1] & WPAD_BUTTON_1) return 1; break; case PAD_BUTTON_R: - if (buttons_hold[i + 1] & WPAD_BUTTON_2) return 1; + if (stateArray[i + 1] & WPAD_BUTTON_2) return 1; break; case PAD_BUTTON_1: - if (buttons_hold[i + 1] & WPAD_BUTTON_1) return 1; + if (stateArray[i + 1] & WPAD_BUTTON_1) return 1; break; case PAD_BUTTON_2: - if (buttons_hold[i + 1] & WPAD_BUTTON_2) return 1; + if (stateArray[i + 1] & WPAD_BUTTON_2) return 1; break; case PAD_BUTTON_Z: - if (buttons_hold[i + 1] & WPAD_BUTTON_Z) return 1; + if (stateArray[i + 1] & WPAD_BUTTON_Z) return 1; break; case PAD_BUTTON_C: - if (buttons_hold[i + 1] & WPAD_BUTTON_C) return 1; + if (stateArray[i + 1] & WPAD_BUTTON_C) return 1; break; case PAD_BUTTON_PLUS: - if (buttons_hold[i + 1] & WPAD_BUTTON_PLUS) return 1; + if (stateArray[i + 1] & WPAD_BUTTON_PLUS) return 1; break; case PAD_BUTTON_MINUS: - if (buttons_hold[i + 1] & WPAD_BUTTON_MINUS) return 1; + if (stateArray[i + 1] & WPAD_BUTTON_MINUS) return 1; break; case PAD_BUTTON_HOME: - if (buttons_hold[i + 1] & WPAD_BUTTON_HOME) return 1; + if (stateArray[i + 1] & WPAD_BUTTON_HOME) return 1; break; } } @@ -510,312 +257,74 @@ int isHeld(int button) { else if (isClassicController(&pads[i]) || isProController(&pads[i])) { switch (button) { case PAD_BUTTON_UP: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_UP) return 1; + if (stateArray[i + 1] & WPAD_CLASSIC_BUTTON_UP) return 1; break; case PAD_BUTTON_DOWN: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_DOWN) return 1; + if (stateArray[i + 1] & WPAD_CLASSIC_BUTTON_DOWN) return 1; break; case PAD_BUTTON_LEFT: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_LEFT) return 1; + if (stateArray[i + 1] & WPAD_CLASSIC_BUTTON_LEFT) return 1; break; case PAD_BUTTON_RIGHT: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_RIGHT) return 1; + if (stateArray[i + 1] & WPAD_CLASSIC_BUTTON_RIGHT) return 1; break; case PAD_BUTTON_A: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_A) return 1; + if (stateArray[i + 1] & WPAD_CLASSIC_BUTTON_A) return 1; break; case PAD_BUTTON_B: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_B) return 1; + if (stateArray[i + 1] & WPAD_CLASSIC_BUTTON_B) return 1; break; case PAD_BUTTON_X: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_X) return 1; + if (stateArray[i + 1] & WPAD_CLASSIC_BUTTON_X) return 1; break; case PAD_BUTTON_Y: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_Y) return 1; + if (stateArray[i + 1] & WPAD_CLASSIC_BUTTON_Y) return 1; break; case PAD_BUTTON_L: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_L) return 1; + if (stateArray[i + 1] & WPAD_CLASSIC_BUTTON_L) return 1; break; case PAD_BUTTON_R: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_R) return 1; + if (stateArray[i + 1] & WPAD_CLASSIC_BUTTON_R) return 1; break; case PAD_BUTTON_ZL: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_ZL) return 1; + if (stateArray[i + 1] & WPAD_CLASSIC_BUTTON_ZL) return 1; break; case PAD_BUTTON_ZR: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_ZR) return 1; + if (stateArray[i + 1] & WPAD_CLASSIC_BUTTON_ZR) return 1; break; case PAD_BUTTON_PLUS: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_PLUS) return 1; + if (stateArray[i + 1] & WPAD_CLASSIC_BUTTON_PLUS) return 1; break; case PAD_BUTTON_MINUS: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_MINUS) return 1; + if (stateArray[i + 1] & WPAD_CLASSIC_BUTTON_MINUS) return 1; break; case PAD_BUTTON_HOME: - if (buttons_hold[i + 1] & WPAD_CLASSIC_BUTTON_HOME) return 1; + if (stateArray[i + 1] & WPAD_CLASSIC_BUTTON_HOME) return 1; break; } //Here, we handle the aforementioned clicky sticks if (isProController(&pads[i])) { switch (button) { case PAD_BUTTON_STICK_L: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; + if (stateArray[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; break; case PAD_BUTTON_STICK_R: - if (buttons_hold[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; - break; - } - } - } - } - } - - return 0; -} - -int isReleased(int button) { - //Check for any button at all - if (button == PAD_BUTTON_ANY) { - for (int i = 0; i < 5; i++) { - if (buttons_released[i] > 0) return 1; - } - } - //VPad buttons - switch (button) { - case PAD_BUTTON_A: - if (buttons_released[0] & VPAD_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_released[0] & VPAD_BUTTON_B) return 1; - break; - - case PAD_BUTTON_X: - if (buttons_released[0] & VPAD_BUTTON_X) return 1; - break; - - case PAD_BUTTON_Y: - if (buttons_released[0] & VPAD_BUTTON_Y) return 1; - break; - - case PAD_BUTTON_UP: - if (buttons_released[0] & VPAD_BUTTON_UP) return 1; - break; - - case PAD_BUTTON_DOWN: - if (buttons_released[0] & VPAD_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_released[0] & VPAD_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_released[0] & VPAD_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_released[0] & VPAD_BUTTON_L) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_released[0] & VPAD_BUTTON_R) return 1; - break; - - case PAD_BUTTON_ZL: - if (buttons_released[0] & VPAD_BUTTON_ZL) return 1; - break; - - case PAD_BUTTON_ZR: - if (buttons_released[0] & VPAD_BUTTON_ZR) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_released[0] & VPAD_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_released[0] & VPAD_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_released[0] & VPAD_BUTTON_HOME) return 1; - break; - - case PAD_BUTTON_SYNC: - if (buttons_released[0] & VPAD_BUTTON_SYNC) return 1; - break; - - case PAD_BUTTON_STICK_L: - if (buttons_released[0] & VPAD_BUTTON_L) return 1; - break; - - case PAD_BUTTON_STICK_R: - if (buttons_released[0] & VPAD_BUTTON_STICK_R) return 1; - break; - - case PAD_BUTTON_TV: - if (buttons_released[0] & VPAD_BUTTON_TV) return 1; - break; - - default: - break; - } - - //Buttons handled by the padscore library - for (int i = 0; i < 4; i++) { - if (padErrors[i] == 0) { - if (isWiimote(&pads[i])) { - switch (button) { - case PAD_BUTTON_UP: - if (buttons_released[i + 1] & WPAD_BUTTON_UP) return 1; - break; - - case PAD_BUTTON_DOWN: - if (buttons_released[i + 1] & WPAD_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_released[i + 1] & WPAD_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_released[i + 1] & WPAD_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_A: - if (buttons_released[i + 1] & WPAD_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_released[i + 1] & WPAD_BUTTON_B) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_released[i + 1] & WPAD_BUTTON_1) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_released[i + 1] & WPAD_BUTTON_2) return 1; - break; - - case PAD_BUTTON_1: - if (buttons_released[i + 1] & WPAD_BUTTON_1) return 1; - break; - - case PAD_BUTTON_2: - if (buttons_released[i + 1] & WPAD_BUTTON_2) return 1; - break; - - case PAD_BUTTON_Z: - if (buttons_released[i + 1] & WPAD_BUTTON_Z) return 1; - break; - - case PAD_BUTTON_C: - if (buttons_released[i + 1] & WPAD_BUTTON_C) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_released[i + 1] & WPAD_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_released[i + 1] & WPAD_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_released[i + 1] & WPAD_BUTTON_HOME) return 1; - break; - } - } - //Turns out the Pro Controller and Classic Controller have almost the exact same mapping - //Except for the Pro Controller having clicky sticks - else if (isClassicController(&pads[i]) || isProController(&pads[i])) { - switch (button) { - case PAD_BUTTON_UP: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_UP) return 1; - break; - - case PAD_BUTTON_DOWN: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_DOWN) return 1; - break; - - case PAD_BUTTON_LEFT: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_LEFT) return 1; - break; - - case PAD_BUTTON_RIGHT: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_RIGHT) return 1; - break; - - case PAD_BUTTON_A: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_A) return 1; - break; - - case PAD_BUTTON_B: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_B) return 1; - break; - - case PAD_BUTTON_X: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_X) return 1; - break; - - case PAD_BUTTON_Y: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_Y) return 1; - break; - - case PAD_BUTTON_L: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_L) return 1; - break; - - case PAD_BUTTON_R: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_R) return 1; - break; - - case PAD_BUTTON_ZL: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_ZL) return 1; - break; - - case PAD_BUTTON_ZR: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_ZR) return 1; - break; - - case PAD_BUTTON_PLUS: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_PLUS) return 1; - break; - - case PAD_BUTTON_MINUS: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_MINUS) return 1; - break; - - case PAD_BUTTON_HOME: - if (buttons_released[i + 1] & WPAD_CLASSIC_BUTTON_HOME) return 1; - break; - } - //Here, we handle the aforementioned clicky sticks - if (isProController(&pads[i])) { - switch (button) { - case PAD_BUTTON_STICK_L: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_STICK_L) return 1; - break; - - case PAD_BUTTON_STICK_R: - if (buttons_released[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; + if (stateArray[i + 1] & WPAD_PRO_BUTTON_STICK_R) return 1; break; } } diff --git a/src/controllers.h b/src/controllers.h index 0caed2b..c343fba 100644 --- a/src/controllers.h +++ b/src/controllers.h @@ -31,20 +31,25 @@ enum buttons { PAD_BUTTON_ANY }; +enum buttonStates { + PRESS, + HOLD, + RELEASE +}; + uint32_t buttons_hold[5]; //Held buttons uint32_t buttons_pressed[5]; //Pressed buttons uint32_t buttons_released[5]; //Released buttons void pingControllers(); -void updatePressedButtons(); -void updateHeldButtons(); -void updateReleasedButtons(); +void updateButtons(); bool stickPos(u8 stick, f32 value); bool isWiimote(KPADData *padData); bool isClassicController(KPADData *padData); bool isProController(KPADData *padData); -int isPressed(int button); -int isHeld(int button); -int isReleased(int button); +int checkButton(int button, int state); +// int isPressed(int button); +// int isHeld(int button); +// int isReleased(int button); #endif //CONTROLLERS_H diff --git a/src/main.c b/src/main.c index 1202c84..b8d3306 100644 --- a/src/main.c +++ b/src/main.c @@ -677,20 +677,18 @@ int Menu_Main(void) { flipBuffers(); while(1) { - updatePressedButtons(); - updateHeldButtons(); - if (isPressed(PAD_BUTTON_ANY) || isHeld(PAD_BUTTON_ANY) || stickPos(4, 0.7)) break; + updateButtons(); + if (checkButton(PAD_BUTTON_ANY, PRESS) || checkButton(PAD_BUTTON_ANY, HOLD) || stickPos(4, 0.7)) break; } - updatePressedButtons(); - updateHeldButtons(); + updateButtons(); - if (isPressed(PAD_BUTTON_DOWN) || isHeld(PAD_BUTTON_DOWN) || stickPos(1, -0.7) || stickPos(3, -0.7)) { + if (checkButton(PAD_BUTTON_DOWN, PRESS) || checkButton(PAD_BUTTON_DOWN, HOLD) || stickPos(1, -0.7) || stickPos(3, -0.7)) { if (entrycount <= 14) cursor = (cursor + 1) % entrycount; else if (cursor < 6) cursor++; else if ((cursor + scroll + 1) % entrycount) scroll++; else cursor = scroll = 0; os_usleep(100000); - } else if (isPressed(PAD_BUTTON_UP) || isHeld(PAD_BUTTON_UP) || stickPos(1, 0.7) || stickPos(3, 0.7)) { + } else if (checkButton(PAD_BUTTON_UP, PRESS) || checkButton(PAD_BUTTON_UP, HOLD) || stickPos(1, 0.7) || stickPos(3, 0.7)) { if (scroll > 0) cursor -= (cursor>6) ? 1 : 0 * (scroll--); else if (cursor > 0) cursor--; else if (entrycount > 14) scroll = entrycount - (cursor = 6) - 1; @@ -698,7 +696,7 @@ int Menu_Main(void) { os_usleep(100000); } - if (isPressed(PAD_BUTTON_LEFT) || isHeld(PAD_BUTTON_LEFT) || stickPos(0, -0.7) || stickPos(2, -0.7)) { + if (checkButton(PAD_BUTTON_LEFT, PRESS) || checkButton(PAD_BUTTON_LEFT, HOLD) || stickPos(0, -0.7) || stickPos(2, -0.7)) { if (menu==3) { if (task == 5) { switch(cursor) { @@ -746,7 +744,7 @@ int Menu_Main(void) { } } os_usleep(100000); - } else if (isPressed(PAD_BUTTON_RIGHT) || isHeld(PAD_BUTTON_RIGHT) || stickPos(0, 0.7) || stickPos(2, 0.7)) { + } else if (checkButton(PAD_BUTTON_RIGHT, PRESS) || checkButton(PAD_BUTTON_RIGHT, HOLD) || stickPos(0, 0.7) || stickPos(2, 0.7)) { if (menu == 3) { if (task == 5) { switch(cursor) { @@ -796,7 +794,7 @@ int Menu_Main(void) { os_usleep(100000); } - if (isPressed(PAD_BUTTON_R)) { + if (checkButton(PAD_BUTTON_R, PRESS)) { if (menu == 1) { tsort = (tsort + 1) % 4; qsort(titles, count, sizeof(Title), titleSort); @@ -806,7 +804,7 @@ int Menu_Main(void) { } } - if (isPressed(PAD_BUTTON_L)) { + if (checkButton(PAD_BUTTON_L, PRESS)) { if ((menu==1) && (tsort > 0)) { sorta *= -1; qsort(titles, count, sizeof(Title), titleSort); @@ -816,7 +814,7 @@ int Menu_Main(void) { } } - if (isPressed(PAD_BUTTON_A)) { + if (checkButton(PAD_BUTTON_A, PRESS)) { clearBuffers(); if (menu < 3) { if (menu == 0) { @@ -928,7 +926,7 @@ int Menu_Main(void) { } break; } } - } else if (isPressed(PAD_BUTTON_B) && menu > 0) { + } else if (checkButton(PAD_BUTTON_B, PRESS) && menu > 0) { clearBuffers(); menu--; cursor = scroll = 0; @@ -938,7 +936,7 @@ int Menu_Main(void) { } if (menu == 2) cursor = cursort; } - if (isPressed(PAD_BUTTON_HOME)) break; + if (checkButton(PAD_BUTTON_HOME, PRESS)) break; } if (tgaBufDRC) free(tgaBufDRC); diff --git a/src/savemng.c b/src/savemng.c index 3f61b48..b329132 100644 --- a/src/savemng.c +++ b/src/savemng.c @@ -299,9 +299,9 @@ bool promptConfirm(Style st, const char* question) { int ret = 0; while(1) { - updatePressedButtons(); - if (isPressed(PAD_BUTTON_ANY)) { - ret = isPressed(PAD_BUTTON_A); + updateButtons(); + if (checkButton(PAD_BUTTON_ANY, PRESS)) { + ret = checkButton(PAD_BUTTON_A, PRESS); break; } } @@ -329,8 +329,8 @@ void promptError(const char* message, ...) { flipBuffers(); va_end(va); while(1) { - updatePressedButtons(); - if (isPressed(PAD_BUTTON_ANY)) break; + updateButtons(); + if (checkButton(PAD_BUTTON_ANY, PRESS)) break; } }